WIP

.github/workflows/npm.yml

@@ -1,446 +0,0 @@
-name: nodejs
-env:
-  DEBUG: napi:*
-  APP_NAME: nodejs
-  MACOSX_DEPLOYMENT_TARGET: '10.13'
-permissions:
-  contents: write
-  id-token: write
-'on':
-  workflow_dispatch:
-    inputs:
-      publish:
-        description: "Publish to npm"
-        required: true
-        type: boolean
-defaults:
-  run:
-    working-directory: ./bindings/nodejs
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-            build: yarn build --target x86_64-apple-darwin
-          - host: windows-latest
-            build: yarn build --target x86_64-pc-windows-msvc
-            target: x86_64-pc-windows-msvc
-          - host: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
-            build: yarn build --target x86_64-unknown-linux-gnu
-          - host: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: yarn build --target x86_64-unknown-linux-musl
-          - host: macos-latest
-            target: aarch64-apple-darwin
-            build: yarn build --target aarch64-apple-darwin
-          - host: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
-            build: yarn build --target aarch64-unknown-linux-gnu
-          - host: ubuntu-latest
-            target: armv7-unknown-linux-gnueabihf
-            setup: |
-              sudo apt-get update
-              sudo apt-get install gcc-arm-linux-gnueabihf -y
-            build: yarn build --target armv7-unknown-linux-gnueabihf
-          - host: ubuntu-latest
-            target: armv7-unknown-linux-musleabihf
-            build: yarn build --target armv7-unknown-linux-musleabihf
-          - host: ubuntu-latest
-            target: aarch64-linux-android
-            build: yarn build --target aarch64-linux-android
-          - host: ubuntu-latest
-            target: armv7-linux-androideabi
-            build: yarn build --target armv7-linux-androideabi
-          - host: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: |-
-              set -e &&
-              rustup target add aarch64-unknown-linux-musl &&
-              yarn build --target aarch64-unknown-linux-musl
-          - host: windows-latest
-            target: aarch64-pc-windows-msvc
-            build: yarn build --target aarch64-pc-windows-msvc
-          - host: ubuntu-latest
-            target: riscv64gc-unknown-linux-gnu
-            setup: |
-              sudo apt-get update
-              sudo apt-get install gcc-riscv64-linux-gnu -y
-            build: yarn build --target riscv64gc-unknown-linux-gnu
-    name: stable - ${{ matrix.settings.target }} - node@20
-    runs-on: ${{ matrix.settings.host }}
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        if: ${{ !matrix.settings.docker }}
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install
-        uses: dtolnay/rust-toolchain@stable
-        if: ${{ !matrix.settings.docker }}
-        with:
-          toolchain: stable
-          targets: ${{ matrix.settings.target }}
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            .cargo-cache
-            target/
-          key: ${{ matrix.settings.target }}-cargo-${{ matrix.settings.host }}
-      - uses: goto-bus-stop/setup-zig@v2
-        if: ${{ matrix.settings.target == 'armv7-unknown-linux-gnueabihf' || matrix.settings.target == 'armv7-unknown-linux-musleabihf' }}
-        with:
-          version: 0.13.0
-      - name: Setup toolchain
-        run: ${{ matrix.settings.setup }}
-        if: ${{ matrix.settings.setup }}
-        shell: bash
-      - name: Install dependencies
-        run: yarn install
-      - name: Build in docker
-        uses: addnab/docker-run-action@v3
-        if: ${{ matrix.settings.docker }}
-        with:
-          image: ${{ matrix.settings.docker }}
-          options: '--user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: ${{ matrix.settings.build }}
-      - name: Build
-        run: ${{ matrix.settings.build }}
-        if: ${{ !matrix.settings.docker }}
-        shell: bash
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bindings-${{ matrix.settings.target }}
-          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
-          if-no-files-found: error
-  test-macOS-windows-binding:
-    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-          - host: windows-latest
-            target: x86_64-pc-windows-msvc
-        node:
-          - '18'
-          - '20'
-    runs-on: ${{ matrix.settings.host }}
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-          architecture: x64
-      - name: Install dependencies
-        run: yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-${{ matrix.settings.target }}
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: yarn test
-  test-linux-x64-gnu-binding:
-    name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-unknown-linux-gnu
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-slim yarn test
-  test-linux-x64-musl-binding:
-    name: Test bindings on x86_64-unknown-linux-musl - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.libc "musl"
-          yarn install
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-unknown-linux-musl
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Test bindings
-        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-alpine yarn test
-  test-linux-aarch64-gnu-binding:
-    name: Test bindings on aarch64-unknown-linux-gnu - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-unknown-linux-gnu
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm64"
-          yarn config set supportedArchitectures.libc "glibc"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:${{ matrix.node }}-slim
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-            ls -la
-  test-linux-aarch64-musl-binding:
-    name: Test bindings on aarch64-unknown-linux-musl - node@${{ matrix.node }}
-    needs:
-      - build
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-unknown-linux-musl
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm64"
-          yarn config set supportedArchitectures.libc "musl"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm64
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:lts-alpine
-          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-  test-linux-arm-gnueabihf-binding:
-    name: Test bindings on armv7-unknown-linux-gnueabihf - node@${{ matrix.node }}
-    needs:
-      - build
-    strategy:
-      fail-fast: false
-      matrix:
-        node:
-          - '18'
-          - '20'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-armv7-unknown-linux-gnueabihf
-          path: bindings/nodejs/
-      - name: List packages
-        run: ls -R .
-        shell: bash
-      - name: Install dependencies
-        run: |
-          yarn config set supportedArchitectures.cpu "arm"
-          yarn install
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: arm
-      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-      - name: Setup and run tests
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:${{ matrix.node }}-bullseye-slim
-          options: '--platform linux/arm/v7 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
-          run: |
-            set -e
-            yarn test
-            ls -la
-  universal-macOS:
-    name: Build universal macOS binary
-    needs:
-      - build
-    runs-on: macos-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download macOS x64 artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-x86_64-apple-darwin
-          path: bindings/nodejs/artifacts
-      - name: Download macOS arm64 artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bindings-aarch64-apple-darwin
-          path: bindings/nodejs/artifacts
-      - name: Combine binaries
-        run: yarn universal
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bindings-universal-apple-darwin
-          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
-          if-no-files-found: error
-  publish:
-    name: Publish
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./bindings/nodejs
-    needs:
-      - test-macOS-windows-binding
-      - test-linux-x64-gnu-binding
-      - test-linux-x64-musl-binding
-      - test-linux-aarch64-gnu-binding
-      - test-linux-aarch64-musl-binding
-      - test-linux-arm-gnueabihf-binding
-      - universal-macOS
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: yarn
-          cache-dependency-path: "bindings/nodejs"
-      - name: Install dependencies
-        run: yarn install
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: bindings/nodejs/artifacts
-      - name: Move artifacts
-        run: yarn artifacts
-      - name: List packages
-        run: ls -R ./npm
-        shell: bash
-      - name: Publish
-        run: |
-          echo "${{ github.event.inputs.publish }}"
-          if [ "${{ github.event.inputs.publish }}" = "true" ]; then
-            echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
-            npm publish --access public
-            echo "Published to npm"
-          else
-            echo "Not a release, skipping publish"
-          fi
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/pypi.yml

@@ -1,143 +0,0 @@
-name: Upload component to Python Package Index
-
-on:
-  workflow_dispatch:
-    inputs:
-      release:
-        type: boolean
-        default: false
-        required: false
-        description: "Release? If false, publish to test.pypi.org, if true, publish to pypi.org"
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          manylinux: auto
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v3
-        with:
-          name: wheels
-          path: bindings/python/dist
-
-  windows:
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        target: [x64, x86]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-          architecture: ${{ matrix.target }}
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v3
-        with:
-          name: wheels
-          path: bindings/python/dist
-
-  macos:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        target: [x86_64, aarch64]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter
-          sccache: 'true'
-          working-directory: bindings/python
-      - name: Upload wheels
-        uses: actions/upload-artifact@v3
-        with:
-          name: wheels
-          path: bindings/python/dist
-
-  sdist:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Build sdist
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist
-          working-directory: bindings/python
-      - name: Upload sdist
-        uses: actions/upload-artifact@v3
-        with:
-          name: wheels
-          path: bindings/python/dist
-
-  publish-to-test-pypi:
-    if: ${{ github.event.inputs.release != 'true' }}
-    name: >-
-        Publish Python 🐍 distribution 📦 to Test PyPI
-    runs-on: ubuntu-latest
-    needs: [linux, windows, macos, sdist]
-    steps:
-      - uses: actions/download-artifact@v3
-        with:
-          name: wheels
-          path: bindings/python/
-      - name: Publish distribution 📦 to Test PyPI
-        uses: PyO3/maturin-action@v1
-        env:
-          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_TEST_API_TOKEN }}
-          MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
-        with:
-          command: upload
-          args: --skip-existing *
-          working-directory: bindings/python
-
-  publish-pypi:
-    if: ${{ github.event.inputs.release == 'true' }}
-    name: >-
-        Publish Python 🐍 distribution 📦 to PyPI
-    runs-on: ubuntu-latest
-    needs: [linux, windows, macos, sdist]
-    steps:
-      - uses: actions/download-artifact@v3
-        with:
-          name: wheels
-          path: bindings/python/
-      - name: Publish distribution 📦 to PyPI
-        uses: PyO3/maturin-action@v1
-        env:
-          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
-          MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
-        with:
-          command: upload
-          args: --skip-existing *
-          working-directory: bindings/python

.gitignore

@@ -1,3 +1,2 @@
 target/*
-**/node_modules/**
+.DS_Store
-.DS_Store

CHANGELOG.md

@@ -7,21 +7,12 @@
 - New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
 - New document server (Thanks Dani!)
 - New function FORMULATEXT
-- Name Manager ([#212](https://github.com/ironcalc/IronCalc/pull/212) [#220](https://github.com/ironcalc/IronCalc/pull/220))
-- Add context menu. We can now insert rows and columns. Freeze and unfreeze rows and columns. Delete rows and columns [#271]
-- Add nodejs bindings [#254]
-- Add python bindings for all platforms
-- Add is split into the product and widget
-- Add Python documentation [#260]
 
 ### Fixed
 
 - Fixed several issues with pasting content
 - Fixed several issues with borders
 - Fixed bug where columns and rows could be resized to negative width and height, respectively
-- Undo/redo when add/delete sheet now works [#270]
-- Numerous small fixes
-- Multiple fixes to the documentation
 
 ## [0.2.0] - 2024-11-06 (The HN release)
 

Cargo.lock

@@ -85,12 +85,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "bitflags"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
-
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -216,15 +210,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
-[[package]]
-name = "convert_case"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.6"
@@ -286,16 +271,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ctor"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
-dependencies = [
- "quote",
- "syn",
-]
-
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -414,7 +389,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.3.0"
+version = "0.2.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -430,7 +405,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.3.0"
+version = "0.2.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -446,17 +421,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "ironcalc_nodejs"
-version = "0.3.1"
-dependencies = [
- "ironcalc",
- "napi",
- "napi-build",
- "napi-derive",
- "serde",
-]
-
 [[package]]
 name = "itertools"
 version = "0.12.1"
@@ -496,16 +460,6 @@ version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
-[[package]]
-name = "libloading"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
-dependencies = [
- "cfg-if",
- "windows-targets",
-]
-
 [[package]]
 name = "log"
 version = "0.4.21"
@@ -536,65 +490,6 @@ dependencies = [
  "adler",
 ]
 
-[[package]]
-name = "napi"
-version = "2.16.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214f07a80874bb96a8433b3cdfc84980d56c7b02e1a0d7ba4ba0db5cef785e2b"
-dependencies = [
- "bitflags",
- "ctor",
- "napi-derive",
- "napi-sys",
- "once_cell",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "napi-build"
-version = "2.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db836caddef23662b94e16bf1f26c40eceb09d6aee5d5b06a7ac199320b69b19"
-
-[[package]]
-name = "napi-derive"
-version = "2.16.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
-dependencies = [
- "cfg-if",
- "convert_case",
- "napi-derive-backend",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "napi-derive-backend"
-version = "1.0.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
-dependencies = [
- "convert_case",
- "once_cell",
- "proc-macro2",
- "quote",
- "regex",
- "semver",
- "syn",
-]
-
-[[package]]
-name = "napi-sys"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
-dependencies = [
- "libloading",
-]
-
 [[package]]
 name = "num-conv"
 version = "0.1.0"
@@ -721,9 +616,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.4"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
+checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -739,9 +634,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.4"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
+checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -749,9 +644,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.4"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
+checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -759,9 +654,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.4"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
+checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -771,9 +666,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.4"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
+checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -784,7 +679,7 @@ dependencies = [
 
 [[package]]
 name = "pyroncalc"
-version = "0.3.0"
+version = "0.1.2"
 dependencies = [
  "ironcalc",
  "pyo3",
@@ -884,12 +779,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
-[[package]]
-name = "semver"
-version = "1.0.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
-
 [[package]]
 name = "serde"
 version = "1.0.197"
@@ -1034,12 +923,6 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
-
 [[package]]
 name = "unindent"
 version = "0.2.3"
@@ -1070,7 +953,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm"
-version = "0.3.2"
+version = "0.1.3"
 dependencies = [
  "ironcalc_base",
  "serde",

Cargo.toml

@@ -6,12 +6,10 @@ members = [
   "xlsx",
   "bindings/wasm",
   "bindings/python",
-  "bindings/nodejs",
 ]
 
 exclude = [
   "generate_locale",
-  "webapp/app.ironcalc.com/server",
 ]
 
 [profile.release]

Makefile

@@ -2,8 +2,7 @@
 lint:
 	cargo fmt -- --check
 	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
-	cd webapp/IronCalc/ && npm install && npm run check
+	cd webapp && npm install && npm run check
-	cd webapp/app.ironcalc.com/frontend/ && npm install && npm run check
 
 .PHONY: format
 format:
@@ -16,7 +15,7 @@ tests: lint
 	# Regretabbly we need to build the wasm twice, once for the nodejs tests
 	# and a second one for the vitest.
 	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
-	cd webapp/IronCalc/ && npm run test
+	cd webapp && npm run test
 	cd bindings/python && ./run_tests.sh && ./run_examples.sh
 
 .PHONY: remove-artifacts

base/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "ironcalc_base"
-version = "0.3.0"
+version = "0.2.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
 repository = "https://github.com/ironcalc/ironcalc/"
-description = "Open source spreadsheet engine"
+description = "The democratization of spreadsheets"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

base/src/actions.rs

@@ -136,33 +136,6 @@ impl Model {
             }),
         );
 
-        // In the list of columns:
-        // * Keep all the columns to the left
-        // * Displace all the columns to the right
-
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-
-        let mut new_columns = Vec::new();
-        for col in worksheet.cols.iter_mut() {
-            // range under study
-            let min = col.min;
-            let max = col.max;
-            if column > max {
-                // If the range under study is to our left, this is a noop
-            } else if column <= min {
-                // If the range under study is to our right, we displace it
-                col.min = min + column_count;
-                col.max = max + column_count;
-            } else {
-                // If the range under study is in the middle we augment it
-                col.max = max + column_count;
-            }
-            new_columns.push(col.clone());
-        }
-        // TODO: If in a row the cell to the right and left have the same style we should copy it
-
-        worksheet.cols = new_columns;
-
         Ok(())
     }
 

base/src/constants.rs

@@ -16,10 +16,3 @@ pub(crate) const LAST_ROW: i32 = 1_048_576;
 // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
 // The 2 days offset is because of Excel 1900 bug
 pub(crate) const EXCEL_DATE_BASE: i32 = 693_594;
-
-// We do not support dates before 1899-12-31.
-pub(crate) const MINIMUM_DATE_SERIAL_NUMBER: i32 = 1;
-
-// Excel can handle dates until the year 9999-12-31
-// 2958465 is the number of days from 1900-01-01 to 9999-12-31
-pub(crate) const MAXIMUM_DATE_SERIAL_NUMBER: i32 = 2_958_465;

base/src/expressions/parser/mod.rs

@@ -642,38 +642,7 @@ impl Parser {
                 position: 0,
                 message: "Unexpected end of input.".to_string(),
             },
-            TokenType::Boolean(value) => {
+            TokenType::Boolean(value) => Node::BooleanKind(value),
-                // Could be a function call "TRUE()"
-                let next_token = self.lexer.peek_token();
-                if next_token == TokenType::LeftParenthesis {
-                    self.lexer.advance_token();
-                    // We parse all the arguments, although technically this is moot
-                    // But is has the upside of transforming `=TRUE( 4 )` into `=TRUE(4)`
-                    let args = match self.parse_function_args() {
-                        Ok(s) => s,
-                        Err(e) => return e,
-                    };
-                    if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: err.position,
-                            message: err.message,
-                        };
-                    }
-                    if value {
-                        return Node::FunctionKind {
-                            kind: Function::True,
-                            args,
-                        };
-                    } else {
-                        return Node::FunctionKind {
-                            kind: Function::False,
-                            args,
-                        };
-                    }
-                }
-                Node::BooleanKind(value)
-            }
             TokenType::Compare(_) => {
                 // A primary Node cannot start with an operator
                 Node::ParseErrorKind {

base/src/formatter/dates.rs

@@ -1,158 +1,18 @@
 use chrono::Datelike;
-use chrono::Days;
 use chrono::Duration;
-use chrono::Months;
 use chrono::NaiveDate;
 
 use crate::constants::EXCEL_DATE_BASE;
-use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
-use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 
-#[inline]
+pub fn from_excel_date(days: i64) -> NaiveDate {
-fn convert_to_serial_number(date: NaiveDate) -> i32 {
-    date.num_days_from_ce() - EXCEL_DATE_BASE
-}
-
-fn is_date_within_range(date: NaiveDate) -> bool {
-    convert_to_serial_number(date) >= MINIMUM_DATE_SERIAL_NUMBER
-        && convert_to_serial_number(date) <= MAXIMUM_DATE_SERIAL_NUMBER
-}
-
-pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
-    if days < MINIMUM_DATE_SERIAL_NUMBER as i64 {
-        return Err(format!(
-            "Excel date must be greater than {}",
-            MINIMUM_DATE_SERIAL_NUMBER
-        ));
-    };
-    if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
-        return Err(format!(
-            "Excel date must be less than {}",
-            MAXIMUM_DATE_SERIAL_NUMBER
-        ));
-    };
     #[allow(clippy::expect_used)]
     let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
-    Ok(dt + Duration::days(days - 2))
+    dt + Duration::days(days - 2)
 }
 
 pub fn date_to_serial_number(day: u32, month: u32, year: i32) -> Result<i32, String> {
     match NaiveDate::from_ymd_opt(year, month, day) {
-        Some(native_date) => Ok(convert_to_serial_number(native_date)),
+        Some(native_date) => Ok(native_date.num_days_from_ce() - EXCEL_DATE_BASE),
         None => Err("Out of range parameters for date".to_string()),
     }
 }
-
-pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Result<i32, String> {
-    // Excel parses `DATE` very permissively. It allows not just for valid date values, but it
-    // allows for invalid dates as well. If you for example enter `DATE(1900, 1, 32)` it will
-    // return the date `1900-02-01`. Despite giving a day that is out of range it will just
-    // wrap the month and year around.
-    //
-    // This function applies that same logic to dates. And does it in the most compatible way as
-    // possible.
-
-    // Special case for the minimum date
-    if year == 1899 && month == 12 && day == 31 {
-        return Ok(MINIMUM_DATE_SERIAL_NUMBER);
-    }
-    let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
-        return Err("Out of range parameters for date".to_string());
-    };
-
-    // One thing to note for example is that even if you started with a year out of range
-    // but tried to increment the months so that it wraps around into within range, excel
-    // would still return an error.
-    //
-    // I.E. DATE(0,13,-1) will return an error, despite it being equivalent to DATE(1,1,0) which
-    // is within range.
-    //
-    // As a result, we have to run range checks as we parse the date from the biggest unit to the
-    // smallest unit.
-    if !is_date_within_range(date) {
-        return Err("Out of range parameters for date".to_string());
-    }
-
-    date = {
-        let month_diff = month - 1;
-        let abs_month = month_diff.unsigned_abs();
-        if month_diff <= 0 {
-            date = date - Months::new(abs_month);
-        } else {
-            date = date + Months::new(abs_month);
-        }
-        if !is_date_within_range(date) {
-            return Err("Out of range parameters for date".to_string());
-        }
-        date
-    };
-
-    date = {
-        let day_diff = day - 1;
-        let abs_day = day_diff.unsigned_abs() as u64;
-        if day_diff <= 0 {
-            date = date - Days::new(abs_day);
-        } else {
-            date = date + Days::new(abs_day);
-        }
-        if !is_date_within_range(date) {
-            return Err("Out of range parameters for date".to_string());
-        }
-        date
-    };
-
-    Ok(convert_to_serial_number(date))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_permissive_date_to_serial_number() {
-        assert_eq!(
-            permissive_date_to_serial_number(42, 42, 2002),
-            date_to_serial_number(12, 7, 2005)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 42, 2002),
-            date_to_serial_number(1, 6, 2005)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 15, 2000),
-            date_to_serial_number(1, 3, 2001)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 49, 2000),
-            date_to_serial_number(1, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(1, 49, 2000),
-            date_to_serial_number(1, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(31, 49, 2000),
-            date_to_serial_number(31, 1, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(256, 49, 2000),
-            date_to_serial_number(12, 9, 2004)
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(256, 1, 2004),
-            date_to_serial_number(12, 9, 2004)
-        );
-    }
-
-    #[test]
-    fn test_max_and_min_dates() {
-        assert_eq!(
-            permissive_date_to_serial_number(31, 12, 9999),
-            Ok(MAXIMUM_DATE_SERIAL_NUMBER),
-        );
-        assert_eq!(
-            permissive_date_to_serial_number(31, 12, 1899),
-            Ok(MINIMUM_DATE_SERIAL_NUMBER),
-        );
-    }
-}

base/src/formatter/format.rs

@@ -154,16 +154,15 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         ParsePart::Date(p) => {
             let tokens = &p.tokens;
             let mut text = "".to_string();
-            let date = match from_excel_date(value as i64) {
+            if !(1.0..=2_958_465.0).contains(&value) {
-                Ok(d) => d,
+                // 2_958_465 is 31 December 9999
-                Err(e) => {
+                return Formatted {
-                    return Formatted {
+                    text: "#VALUE!".to_owned(),
-                        text: "#VALUE!".to_owned(),
+                    color: None,
-                        color: None,
+                    error: Some("Date negative or too long".to_owned()),
-                        error: Some(e),
+                };
-                    }
+            }
-                }
+            let date = from_excel_date(value as i64);
-            };
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {

base/src/functions/date_and_time.rs

@@ -3,11 +3,8 @@ use chrono::Datelike;
 use chrono::Months;
 use chrono::Timelike;
 
-use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
-use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 use crate::expressions::types::CellReferenceIndex;
 use crate::formatter::dates::date_to_serial_number;
-use crate::formatter::dates::permissive_date_to_serial_number;
 use crate::model::get_milliseconds_since_epoch;
 use crate::{
     calc_result::CalcResult, constants::EXCEL_DATE_BASE, expressions::parser::Node,
@@ -21,19 +18,20 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Function DAY parameter 1 value is negative. It should be positive or zero.".to_string(),
+                    };
+                }
+                t
+            }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
+        let date = from_excel_date(serial_number);
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                }
-            }
-        };
         let day = date.day() as f64;
         CalcResult::Number(day)
     }
@@ -44,19 +42,20 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Function MONTH parameter 1 value is negative. It should be positive or zero.".to_string(),
+                    };
+                }
+                t
+            }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
+        let date = from_excel_date(serial_number);
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                }
-            }
-        };
         let month = date.month() as f64;
         CalcResult::Number(month)
     }
@@ -80,23 +79,6 @@ impl Model {
             }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                }
-            }
-        };
-        if serial_number > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Function DAY parameter 1 value is too large.".to_string(),
-            };
-        }
 
         let months = match self.get_number_no_bools(&args[1], cell) {
             Ok(c) => {
@@ -109,9 +91,9 @@ impl Model {
         let months_abs = months.unsigned_abs();
 
         let native_date = if months > 0 {
-            date + Months::new(months_abs)
+            from_excel_date(serial_number) + Months::new(months_abs)
         } else {
-            date - Months::new(months_abs)
+            from_excel_date(serial_number) - Months::new(months_abs)
         };
 
         // Instead of calculating the end of month we compute the first day of the following month
@@ -155,18 +137,32 @@ impl Model {
         let month = match self.get_number(&args[1], cell) {
             Ok(c) => {
                 let t = c.floor();
-                t as i32
+                if t < 0.0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Out of range parameters for date".to_string(),
+                    };
+                }
+                t as u32
             }
             Err(s) => return s,
         };
         let day = match self.get_number(&args[2], cell) {
             Ok(c) => {
                 let t = c.floor();
-                t as i32
+                if t < 0.0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Out of range parameters for date".to_string(),
+                    };
+                }
+                t as u32
             }
             Err(s) => return s,
         };
-        match permissive_date_to_serial_number(day, month, year) {
+        match date_to_serial_number(day, month, year) {
             Ok(serial_number) => CalcResult::Number(serial_number as f64),
             Err(message) => CalcResult::Error {
                 error: Error::NUM,
@@ -182,19 +178,20 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
+                let t = c.floor() as i64;
+                if t < 0 {
+                    return CalcResult::Error {
+                        error: Error::NUM,
+                        origin: cell,
+                        message: "Function YEAR parameter 1 value is negative. It should be positive or zero.".to_string(),
+                    };
+                }
+                t
+            }
             Err(s) => return s,
         };
-        let date = match from_excel_date(serial_number) {
+        let date = from_excel_date(serial_number);
-            Ok(date) => date,
-            Err(_) => {
-                return CalcResult::Error {
-                    error: Error::NUM,
-                    origin: cell,
-                    message: "Out of range parameters for date".to_string(),
-                }
-            }
-        };
         let year = date.year() as f64;
         CalcResult::Number(year)
     }
@@ -206,18 +203,19 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => c.floor() as i64,
+            Ok(c) => {
-            Err(s) => return s,
+                let t = c.floor() as i64;
-        };
+                if t < 0 {
-        let date = match from_excel_date(serial_number) {
+                    return CalcResult::Error {
-            Ok(date) => date,
+                        error: Error::NUM,
-            Err(_) => {
+                        origin: cell,
-                return CalcResult::Error {
+                        message: "Parameter 1 value is negative. It should be positive or zero."
-                    error: Error::NUM,
+                            .to_string(),
-                    origin: cell,
+                    };
-                    message: "Out of range parameters for date".to_string(),
                 }
+                t
             }
+            Err(s) => return s,
         };
 
         let months = match self.get_number(&args[1], cell) {
@@ -231,13 +229,13 @@ impl Model {
         let months_abs = months.unsigned_abs();
 
         let native_date = if months > 0 {
-            date + Months::new(months_abs)
+            from_excel_date(serial_number) + Months::new(months_abs)
         } else {
-            date - Months::new(months_abs)
+            from_excel_date(serial_number) - Months::new(months_abs)
         };
 
         let serial_number = native_date.num_days_from_ce() - EXCEL_DATE_BASE;
-        if serial_number < MINIMUM_DATE_SERIAL_NUMBER {
+        if serial_number < 0 {
             return CalcResult::Error {
                 error: Error::NUM,
                 origin: cell,

base/src/functions/engineering/complex.rs

@@ -188,7 +188,10 @@ impl Model {
         node: &Node,
         cell: CellReferenceIndex,
     ) -> Result<(f64, f64, Suffix), CalcResult> {
-        let value = self.get_string(node, cell)?;
+        let value = match self.get_string(node, cell) {
+            Ok(s) => s,
+            Err(s) => return Err(s),
+        };
         if value.is_empty() {
             return Ok((0.0, 0.0, Suffix::I));
         }

base/src/functions/financial.rs

@@ -2,7 +2,7 @@ use chrono::Datelike;
 
 use crate::{
     calc_result::CalcResult,
-    constants::{LAST_COLUMN, LAST_ROW, MAXIMUM_DATE_SERIAL_NUMBER, MINIMUM_DATE_SERIAL_NUMBER},
+    constants::{LAST_COLUMN, LAST_ROW},
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     formatter::dates::from_excel_date,
     model::Model,
@@ -13,32 +13,37 @@ use super::financial_util::{compute_irr, compute_npv, compute_rate, compute_xirr
 // See:
 // https://github.com/apache/openoffice/blob/c014b5f2b55cff8d4b0c952d5c16d62ecde09ca1/main/scaddins/source/analysis/financial.cxx
 
-fn is_less_than_one_year(start_date: i64, end_date: i64) -> Result<bool, String> {
+// FIXME: Is this enough?
-    let end = from_excel_date(end_date)?;
+fn is_valid_date(date: f64) -> bool {
-    let start = from_excel_date(start_date)?;
+    date > 0.0
+}
+
+fn is_less_than_one_year(start_date: i64, end_date: i64) -> bool {
     if end_date - start_date < 365 {
-        return Ok(true);
+        return true;
     }
+    let end = from_excel_date(end_date);
+    let start = from_excel_date(start_date);
     let end_year = end.year();
     let start_year = start.year();
     if end_year == start_year {
-        return Ok(true);
+        return true;
     }
     if end_year != start_year + 1 {
-        return Ok(false);
+        return false;
     }
     let start_month = start.month();
     let end_month = end.month();
     if end_month < start_month {
-        return Ok(true);
+        return true;
     }
     if end_month > start_month {
-        return Ok(false);
+        return false;
     }
     // we are one year later same month
     let start_day = start.day();
     let end_day = end.day();
-    Ok(end_day <= start_day)
+    end_day <= start_day
 }
 
 fn compute_payment(
@@ -431,7 +436,7 @@ impl Model {
         }
         if rate == -1.0 {
             return CalcResult::Error {
-                error: Error::DIV,
+                error: Error::NUM,
                 origin: cell,
                 message: "Rate must be != -1".to_string(),
             };
@@ -918,9 +923,7 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
+            if !is_valid_date(*date) {
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
                 // Excel docs claim that if any number in dates is not a valid date,
                 // XNPV returns the #VALUE! error value, but it seems to return #VALUE!
                 return CalcResult::new_error(
@@ -986,9 +989,7 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
+            if !is_valid_date(*date) {
-                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
-            {
                 return CalcResult::new_error(
                     Error::NUM,
                     cell,
@@ -1372,10 +1373,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
-            Ok(f) => f,
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
+        }
-        };
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1383,7 +1383,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1437,10 +1437,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
-            Ok(f) => f,
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
+        }
-        };
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1448,7 +1447,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1488,10 +1487,9 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
+        if !is_valid_date(settlement) || !is_valid_date(maturity) {
-            Ok(f) => f,
+            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
-            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
+        }
-        };
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1499,7 +1497,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !less_than_one_year {
+        if !is_less_than_one_year(settlement as i64, maturity as i64) {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,

base/src/functions/logical.rs

@@ -7,22 +7,6 @@ use crate::{
 use super::util::compare_values;
 
 impl Model {
-    pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            CalcResult::Boolean(true)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
-    pub(crate) fn fn_false(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() {
-            CalcResult::Boolean(false)
-        } else {
-            CalcResult::new_args_number_error(cell)
-        }
-    }
-
     pub(crate) fn fn_if(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 2 || args.len() == 3 {
             let cond_result = self.get_boolean(&args[0], cell);

base/src/functions/mod.rs

@@ -949,7 +949,7 @@ impl Model {
         match kind {
             // Logical
             Function::And => self.fn_and(args, cell),
-            Function::False => self.fn_false(args, cell),
+            Function::False => CalcResult::Boolean(false),
             Function::If => self.fn_if(args, cell),
             Function::Iferror => self.fn_iferror(args, cell),
             Function::Ifna => self.fn_ifna(args, cell),
@@ -957,7 +957,7 @@ impl Model {
             Function::Not => self.fn_not(args, cell),
             Function::Or => self.fn_or(args, cell),
             Function::Switch => self.fn_switch(args, cell),
-            Function::True => self.fn_true(args, cell),
+            Function::True => CalcResult::Boolean(true),
             Function::Xor => self.fn_xor(args, cell),
             // Math and trigonometry
             Function::Sin => self.fn_sin(args, cell),

base/src/model.rs

@@ -960,7 +960,10 @@ impl Model {
                 }
             }
         }
-        let sheet = self.get_sheet_index_by_name(&sheet_name)?;
+        let sheet = match self.get_sheet_index_by_name(&sheet_name) {
+            Some(s) => s,
+            None => return None,
+        };
         let row = match row.parse::<i32>() {
             Ok(r) => r,
             Err(_) => return None,
@@ -1872,29 +1875,12 @@ impl Model {
     }
 
     /// Returns the style for cell (`sheet`, `row`, `column`)
-    /// If the cell does not have a style defined we check the row, otherwise the column and finally a default
     pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let style = self.workbook.styles.get_style(style_index)?;
         Ok(style)
     }
 
-    /// Returns the style defined in a cell if any.
-    pub fn get_cell_style_or_none(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<Option<Style>, String> {
-        let style = self
-            .workbook
-            .worksheet(sheet)?
-            .cell(row, column)
-            .map(|c| self.workbook.styles.get_style(c.get_style()))
-            .transpose();
-        style
-    }
-
     /// Returns an internal binary representation of the workbook
     ///
     /// See also:
@@ -2178,73 +2164,6 @@ impl Model {
             Err("Defined name not found".to_string())
         }
     }
-    /// Returns the style object of a column, if any
-    pub fn get_column_style(&self, sheet: u32, column: i32) -> Result<Option<Style>, String> {
-        if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
-            let cols = &worksheet.cols;
-            for col in cols {
-                if column >= col.min && column <= col.max {
-                    if let Some(style_index) = col.style {
-                        let style = self.workbook.styles.get_style(style_index)?;
-                        return Ok(Some(style));
-                    }
-                    return Ok(None);
-                }
-            }
-            Ok(None)
-        } else {
-            Err("Invalid sheet".to_string())
-        }
-    }
-
-    /// Returns the style object of a row, if any
-    pub fn get_row_style(&self, sheet: u32, row: i32) -> Result<Option<Style>, String> {
-        if let Some(worksheet) = self.workbook.worksheets.get(sheet as usize) {
-            let rows = &worksheet.rows;
-            for r in rows {
-                if row == r.r {
-                    let style = self.workbook.styles.get_style(r.s)?;
-                    return Ok(Some(style));
-                }
-            }
-            Ok(None)
-        } else {
-            Err("Invalid sheet".to_string())
-        }
-    }
-
-    /// Sets a column with style
-    pub fn set_column_style(
-        &mut self,
-        sheet: u32,
-        column: i32,
-        style: &Style,
-    ) -> Result<(), String> {
-        let style_index = self.workbook.styles.get_style_index_or_create(style);
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_column_style(column, style_index)
-    }
-
-    /// Sets a row with style
-    pub fn set_row_style(&mut self, sheet: u32, row: i32, style: &Style) -> Result<(), String> {
-        let style_index = self.workbook.styles.get_style_index_or_create(style);
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_row_style(row, style_index)
-    }
-
-    /// Deletes the style of a column if the is any
-    pub fn delete_column_style(&mut self, sheet: u32, column: i32) -> Result<(), String> {
-        self.workbook
-            .worksheet_mut(sheet)?
-            .delete_column_style(column)
-    }
-
-    /// Deletes the style of a row if there is any
-    pub fn delete_row_style(&mut self, sheet: u32, row: i32) -> Result<(), String> {
-        self.workbook.worksheet_mut(sheet)?.delete_row_style(row)
-    }
 }
 
 #[cfg(test)]

base/src/new_empty.rs

@@ -301,7 +301,7 @@ impl Model {
         };
         if sheet_index >= sheet_count {
             return Err("Sheet index too large".to_string());
-        };
+        }
         self.workbook.worksheets.remove(sheet_index as usize);
         self.reset_parsed_structures();
         Ok(())

base/src/styles.rs

@@ -4,6 +4,8 @@ use crate::{
     types::{Border, CellStyles, CellXfs, Fill, Font, NumFmt, Style, Styles},
 };
 
+// TODO: Move Styles and all related types from crate::types here
+// Not doing it right now to not have conflicts with exporter branch
 impl Styles {
     fn get_font_index(&self, font: &Font) -> Option<i32> {
         for (font_index, item) in self.fonts.iter().enumerate() {

base/src/test/mod.rs

@@ -13,7 +13,6 @@ mod test_fn_averageifs;
 mod test_fn_choose;
 mod test_fn_concatenate;
 mod test_fn_count;
-mod test_fn_day;
 mod test_fn_exact;
 mod test_fn_financial;
 mod test_fn_formulatext;
@@ -37,13 +36,11 @@ mod test_model_cell_clear_all;
 mod test_model_is_empty_cell;
 mod test_move_formula;
 mod test_quote_prefix;
-mod test_row_column_styles;
 mod test_set_user_input;
 mod test_sheet_markup;
 mod test_sheets;
 mod test_styles;
 mod test_trigonometric;
-mod test_true_false;
 mod test_workbook;
 mod test_worksheet;
 pub(crate) mod util;

base/src/test/test_date_and_time.rs

@@ -37,12 +37,12 @@ fn test_fn_date_arguments() {
     assert_eq!(model._get_text("A3"), *"#ERROR!");
     assert_eq!(model._get_text("A4"), *"#ERROR!");
 
-    assert_eq!(model._get_text("A5"), *"10/10/1974");
+    assert_eq!(model._get_text("A5"), *"#NUM!");
-    assert_eq!(model._get_text("A6"), *"21/01/1975");
+    assert_eq!(model._get_text("A6"), *"#NUM!");
-    assert_eq!(model._get_text("A7"), *"10/02/1976");
+    assert_eq!(model._get_text("A7"), *"#NUM!");
-    assert_eq!(model._get_text("A8"), *"02/03/1975");
+    assert_eq!(model._get_text("A8"), *"#NUM!");
 
-    assert_eq!(model._get_text("A9"), *"01/03/1975");
+    assert_eq!(model._get_text("A9"), *"#NUM!");
     assert_eq!(model._get_text("A10"), *"29/02/1976");
     assert_eq!(
         model.get_cell_value_by_ref("Sheet1!A10"),
@@ -64,18 +64,15 @@ fn test_date_out_of_range() {
 
     // year (actually years < 1900 don't really make sense)
     model._set("C1", "=DATE(-1, 5, 5)");
-    // excel is not compatible with years past 9999
-    model._set("C2", "=DATE(10000, 5, 5)");
 
     model.evaluate();
 
-    assert_eq!(model._get_text("A1"), *"10/12/2021");
+    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"10/01/2023");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
-    assert_eq!(model._get_text("B1"), *"30/04/2042");
+    assert_eq!(model._get_text("B1"), *"#NUM!");
-    assert_eq!(model._get_text("B2"), *"01/06/2025");
+    assert_eq!(model._get_text("B2"), *"#NUM!");
 
     assert_eq!(model._get_text("C1"), *"#NUM!");
-    assert_eq!(model._get_text("C2"), *"#NUM!");
 }
 
 #[test]
@@ -132,7 +129,8 @@ fn test_day_small_serial() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
+    // This agrees with Google Docs and disagrees with Excel
+    assert_eq!(model._get_text("A2"), *"30");
     // Excel thinks is Feb 29, 1900
     assert_eq!(model._get_text("A3"), *"28");
 
@@ -152,7 +150,8 @@ fn test_month_small_serial() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
+    // This agrees with Google Docs and disagrees with Excel
+    assert_eq!(model._get_text("A2"), *"12");
     // We agree with Excel here (We are both in Feb)
     assert_eq!(model._get_text("A3"), *"2");
 
@@ -172,7 +171,8 @@ fn test_year_small_serial() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
+    // This agrees with Google Docs and disagrees with Excel
+    assert_eq!(model._get_text("A2"), *"1899");
 
     assert_eq!(model._get_text("A3"), *"1900");
 
@@ -204,10 +204,7 @@ fn test_date_early_dates() {
         model.get_cell_value_by_ref("Sheet1!A2"),
         Ok(CellValue::Number(60.0))
     );
-
+    assert_eq!(model._get_text("B2"), *"#NUM!");
-    // This does not agree with Excel, instead of mistakenly allowing
-    // for Feb 29, it will auto-wrap to the next day after Feb 28.
-    assert_eq!(model._get_text("B2"), *"01/03/1900");
 
     // This agrees with Excel from he onward
     assert_eq!(model._get_text("A3"), *"01/03/1900");

base/src/test/test_fn_day.rs

@@ -1,15 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_fn_date_arguments() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=DAY(95051806)");
-    model._set("A2", "=DAY(2958465)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"31");
-}

base/src/test/test_row_column_styles.rs

@@ -1,32 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{constants::DEFAULT_COLUMN_WIDTH, test::util::new_empty_model};
-
-#[test]
-fn test_model_set_cells_with_values_styles() {
-    let mut model = new_empty_model();
-
-    let style_base = model.get_style_for_cell(0, 1, 1).unwrap();
-    let mut style = style_base.clone();
-    style.font.b = true;
-
-    model.set_column_style(0, 10, &style).unwrap();
-
-    assert!(model.get_style_for_cell(0, 21, 10).unwrap().font.b);
-
-    model.delete_column_style(0, 10).unwrap();
-
-    // There are no styles in the column
-    assert!(model.workbook.worksheets[0].cols.is_empty());
-
-    // lets change the column width and check it does not affect the style
-    model
-        .set_column_width(0, 10, DEFAULT_COLUMN_WIDTH * 2.0)
-        .unwrap();
-    model.set_column_style(0, 10, &style).unwrap();
-
-    model.delete_column_style(0, 10).unwrap();
-
-    // There are no styles in the column
-    assert!(model.workbook.worksheets[0].cols.len() == 1);
-}

base/src/test/test_true_false.rs

@@ -1,25 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn true_false_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=TRUE( )");
-    model._set("A2", "=FALSE( )");
-    model._set("A3", "=TRUE( 4 )");
-    model._set("A4", "=FALSE( 4 )");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"TRUE");
-    assert_eq!(model._get_text("A2"), *"FALSE");
-
-    assert_eq!(model._get_formula("A1"), *"=TRUE()");
-    assert_eq!(model._get_formula("A2"), *"=FALSE()");
-
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_formula("A3"), *"=TRUE(4)");
-    assert_eq!(model._get_formula("A4"), *"=FALSE(4)");
-}

base/src/test/user_model/mod.rs

@@ -3,9 +3,7 @@ mod test_autofill_columns;
 mod test_autofill_rows;
 mod test_border;
 mod test_clear_cells;
-mod test_column_style;
 mod test_defined_names;
-mod test_delete_row_column_formatting;
 mod test_diff_queue;
 mod test_evaluation;
 mod test_general;
@@ -15,11 +13,9 @@ mod test_on_area_selection;
 mod test_on_expand_selected_range;
 mod test_on_paste_styles;
 mod test_paste_csv;
-mod test_recursive;
 mod test_rename_sheet;
 mod test_row_column;
 mod test_sheet_state;
-mod test_sheets_undo_redo;
 mod test_styles;
 mod test_to_from_bytes;
 mod test_undo_redo;

base/src/test/user_model/test_add_delete_sheets.rs

@@ -9,7 +9,7 @@ fn add_undo_redo() {
     model.set_user_input(1, 1, 1, "=1 + 1").unwrap();
     model.set_user_input(1, 1, 2, "=A1*3").unwrap();
     model
-        .set_columns_width(1, 5, 5, 5.0 * DEFAULT_COLUMN_WIDTH)
+        .set_column_width(1, 5, 5.0 * DEFAULT_COLUMN_WIDTH)
         .unwrap();
     model.new_sheet().unwrap();
     model.set_user_input(2, 1, 1, "=Sheet2!B1").unwrap();
@@ -25,6 +25,9 @@ fn add_undo_redo() {
     assert_eq!(model.get_formatted_cell_value(2, 1, 1), Ok("6".to_string()));
 
     model.delete_sheet(1).unwrap();
+
+    assert!(!model.can_undo());
+    assert!(!model.can_redo());
 }
 
 #[test]

base/src/test/user_model/test_border.rs

@@ -520,19 +520,14 @@ fn borders_top() {
     .unwrap();
     model.set_area_with_border(range, &border_area).unwrap();
     check_borders(&model);
-    for row in 4..9 {
+    for row in 5..9 {
         for column in 6..9 {
             let style = model.get_cell_style(0, row, column).unwrap();
             let border_item = BorderItem {
                 style: BorderStyle::Thin,
                 color: Some("#FF5566".to_string()),
             };
-            let bottom = if row != 4 {
+            let bottom = if row == 8 {
-                None
-            } else {
-                Some(border_item.clone())
-            };
-            let top = if row != 5 {
                 None
             } else {
                 Some(border_item.clone())
@@ -542,7 +537,7 @@ fn borders_top() {
                 diagonal_down: false,
                 left: None,
                 right: None,
-                top,
+                top: Some(border_item.clone()),
                 bottom,
                 diagonal: None,
             };
@@ -652,12 +647,12 @@ fn borders_right() {
                 style: BorderStyle::Thin,
                 color: Some("#FF5566".to_string()),
             };
-            let left = if column != 9 {
+            let left = if column == 6 {
                 None
             } else {
                 Some(border_item.clone())
             };
-            let right = if column != 8 {
+            let right = if column == 9 {
                 None
             } else {
                 Some(border_item.clone())
@@ -710,7 +705,7 @@ fn borders_bottom() {
                 color: Some("#FF5566".to_string()),
             };
             // The top will also have a value for all but the first one
-            let bottom = if row != 8 {
+            let top = if row == 5 {
                 None
             } else {
                 Some(border_item.clone())
@@ -720,8 +715,8 @@ fn borders_bottom() {
                 diagonal_down: false,
                 left: None,
                 right: None,
-                top: None,
+                top,
-                bottom,
+                bottom: Some(border_item.clone()),
                 diagonal: None,
             };
             assert_eq!(style.border, expected_border);
@@ -756,13 +751,18 @@ fn borders_left() {
     model.set_area_with_border(range, &border_area).unwrap();
 
     for row in 5..9 {
-        for column in 6..9 {
+        for column in 5..9 {
             let style = model.get_cell_style(0, row, column).unwrap();
             let border_item = BorderItem {
                 style: BorderStyle::Thin,
                 color: Some("#FF5566".to_string()),
             };
-            let left = if column != 6 {
+            let left = if column == 5 {
+                None
+            } else {
+                Some(border_item.clone())
+            };
+            let right = if column == 8 {
                 None
             } else {
                 Some(border_item.clone())
@@ -771,29 +771,13 @@ fn borders_left() {
                 diagonal_up: false,
                 diagonal_down: false,
                 left,
-                right: None,
+                right,
                 top: None,
                 bottom: None,
                 diagonal: None,
             };
             assert_eq!(style.border, expected_border);
         }
-        // Column 5 has a border to the right, of course:
-        let style = model.get_cell_style(0, row, 5).unwrap();
-        let border_item = BorderItem {
-            style: BorderStyle::Thin,
-            color: Some("#FF5566".to_string()),
-        };
-        let expected_border = Border {
-            diagonal_up: false,
-            diagonal_down: false,
-            left: None,
-            right: Some(border_item.clone()),
-            top: None,
-            bottom: None,
-            diagonal: None,
-        };
-        assert_eq!(style.border, expected_border);
     }
 }
 
@@ -1034,7 +1018,10 @@ fn border_top() {
         style: BorderStyle::Thin,
         color: Some("#F2F2F2".to_string()),
     };
-    assert_eq!(model._get_cell_actual_border("C4").top, Some(border_item));
+    assert_eq!(
+        model._get_cell_actual_border("C4").bottom,
+        Some(border_item)
+    );
 
     model.undo().unwrap();
 

base/src/test/user_model/test_column_style.rs

@@ -1,504 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
-use crate::expressions::types::Area;
-use crate::UserModel;
-
-#[test]
-fn column_width() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert!(!style.font.i);
-    assert!(!style.font.b);
-    assert!(!style.font.u);
-    assert!(!style.font.strike);
-    assert_eq!(style.font.color, Some("#000000".to_owned()));
-
-    // Set the whole column style and check it works
-    model.update_range_style(&range, "font.b", "true").unwrap();
-    let style = model.get_cell_style(0, 109, 7).unwrap();
-    assert!(style.font.b);
-
-    // undo and check it works
-    model.undo().unwrap();
-    let style = model.get_cell_style(0, 109, 7).unwrap();
-    assert!(!style.font.b);
-
-    // redo and check it works
-    model.redo().unwrap();
-    let style = model.get_cell_style(0, 109, 7).unwrap();
-    assert!(style.font.b);
-
-    // change the column width and check it does not affect the style
-    model
-        .set_columns_width(0, 7, 7, DEFAULT_COLUMN_WIDTH * 2.0)
-        .unwrap();
-    let style = model.get_cell_style(0, 109, 7).unwrap();
-    assert!(style.font.b);
-}
-
-#[test]
-fn existing_style() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    let cell_g123 = Area {
-        sheet: 0,
-        row: 123,
-        column: 7,
-        width: 1,
-        height: 1,
-    };
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    // Set G123 background to red
-    model
-        .update_range_style(&cell_g123, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // Now set the style of the whole column
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    // Get the style of G123
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_owned()));
-
-    model.undo().unwrap();
-
-    // Check the style of G123 is now what it was before
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_owned()));
-
-    model.redo().unwrap();
-
-    // Check G123 has the column style now
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_owned()));
-}
-
-#[test]
-fn row_column() {
-    // We set the row style, then a column style
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_3_range = Area {
-        sheet: 0,
-        row: 3,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // update the row style
-    model
-        .update_range_style(&row_3_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // update the column style
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    // Check G3 has the column style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_owned()));
-
-    // undo twice. Color must be default
-    model.undo().unwrap();
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_owned()));
-    model.undo().unwrap();
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-}
-
-#[test]
-fn column_row() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    let default_style = model.get_cell_style(0, 3, 7).unwrap();
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_3_range = Area {
-        sheet: 0,
-        row: 3,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // update the column style
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    // update the row style
-    model
-        .update_range_style(&row_3_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // Check G3 has the row style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_owned()));
-
-    model.undo().unwrap();
-
-    // Check G3 has the column style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_owned()));
-
-    model.undo().unwrap();
-
-    // Check G3 has the default_style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, default_style.fill.bg_color);
-}
-
-#[test]
-fn row_column_column() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    let column_c_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 3,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let column_e_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 5,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_5_range = Area {
-        sheet: 0,
-        row: 5,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // update the row style
-    model
-        .update_range_style(&row_5_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // update the column style
-    model
-        .update_range_style(&column_c_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    model
-        .update_range_style(&column_e_range, "fill.bg_color", "#CCC111")
-        .unwrap();
-
-    model.undo().unwrap();
-    model.undo().unwrap();
-    model.undo().unwrap();
-
-    // Test E5 has the default style
-    let style = model.get_cell_style(0, 5, 5).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-}
-
-#[test]
-fn width_column_undo() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    model
-        .set_columns_width(0, 7, 7, DEFAULT_COLUMN_WIDTH * 2.0)
-        .unwrap();
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#CCC111")
-        .unwrap();
-
-    model.undo().unwrap();
-
-    assert_eq!(
-        model.get_column_width(0, 7).unwrap(),
-        DEFAULT_COLUMN_WIDTH * 2.0
-    );
-}
-
-#[test]
-fn height_row_undo() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model
-        .set_rows_height(0, 10, 10, DEFAULT_ROW_HEIGHT * 2.0)
-        .unwrap();
-
-    let row_10_range = Area {
-        sheet: 0,
-        row: 10,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    model
-        .update_range_style(&row_10_range, "fill.bg_color", "#CCC111")
-        .unwrap();
-
-    assert_eq!(
-        model.get_row_height(0, 10).unwrap(),
-        2.0 * DEFAULT_ROW_HEIGHT
-    );
-    model.undo().unwrap();
-    assert_eq!(
-        model.get_row_height(0, 10).unwrap(),
-        2.0 * DEFAULT_ROW_HEIGHT
-    );
-    model.undo().unwrap();
-    assert_eq!(model.get_row_height(0, 10).unwrap(), DEFAULT_ROW_HEIGHT);
-}
-
-#[test]
-fn cell_row_undo() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let cell_g12 = Area {
-        sheet: 0,
-        row: 12,
-        column: 7,
-        width: 1,
-        height: 1,
-    };
-
-    let row_12_range = Area {
-        sheet: 0,
-        row: 12,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // Set G12 background to red
-    model
-        .update_range_style(&cell_g12, "fill.bg_color", "#333444")
-        .unwrap();
-
-    model
-        .update_range_style(&row_12_range, "fill.bg_color", "#CCC111")
-        .unwrap();
-
-    let style = model.get_cell_style(0, 12, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#CCC111".to_string()));
-    model.undo().unwrap();
-
-    let style = model.get_cell_style(0, 12, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_string()));
-}
-
-#[test]
-fn set_column_style_then_cell() {
-    // We check that if we set a cell style in a column that already has a style
-    // the styles compound
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let cell_g12 = Area {
-        sheet: 0,
-        row: 12,
-        column: 7,
-        width: 1,
-        height: 1,
-    };
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    // Set G12 background to red
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    model
-        .update_range_style(&cell_g12, "alignment.horizontal", "center")
-        .unwrap();
-
-    let style = model.get_cell_style(0, 12, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_string()));
-
-    model.undo().unwrap();
-    model.undo().unwrap();
-    let style = model.get_cell_style(0, 12, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-}
-
-#[test]
-fn set_row_style_then_cell() {
-    // We check that if we set a cell style in a column that already has a style
-    // the styles compound
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let cell_g12 = Area {
-        sheet: 0,
-        row: 12,
-        column: 7,
-        width: 1,
-        height: 1,
-    };
-
-    let row_12_range = Area {
-        sheet: 0,
-        row: 12,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // Set G12 background to red
-    model
-        .update_range_style(&row_12_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    model
-        .update_range_style(&cell_g12, "alignment.horizontal", "center")
-        .unwrap();
-
-    let style = model.get_cell_style(0, 12, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_string()));
-}
-
-#[test]
-fn column_style_then_row_alignment() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-    let row_3_range = Area {
-        sheet: 0,
-        row: 3,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-    model
-        .update_range_style(&row_3_range, "alignment.horizontal", "center")
-        .unwrap();
-    // check the row alignment does not affect the column style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_string()));
-}
-
-#[test]
-fn column_style_then_width() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-    model
-        .set_columns_width(0, 7, 7, DEFAULT_COLUMN_WIDTH * 2.0)
-        .unwrap();
-
-    // Check column width worked:
-    assert_eq!(
-        model.get_column_width(0, 7).unwrap(),
-        DEFAULT_COLUMN_WIDTH * 2.0
-    );
-}
-
-#[test]
-fn test_row_column_column() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    let column_c_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 3,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let column_e_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 5,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_5_range = Area {
-        sheet: 0,
-        row: 5,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // update the row style
-    model
-        .update_range_style(&row_5_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // update the column style
-    model
-        .update_range_style(&column_c_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    model
-        .update_range_style(&column_e_range, "fill.bg_color", "#CCC111")
-        .unwrap();
-
-    // test E5 has the column style
-    let style = model.get_cell_style(0, 5, 5).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#CCC111".to_string()));
-}

base/src/test/user_model/test_defined_names.rs

@@ -396,30 +396,3 @@ fn undo_redo() {
         Ok("Hola!".to_string())
     );
 }
-
-#[test]
-fn change_scope_to_first_sheet() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet().unwrap();
-    model.set_user_input(0, 1, 1, "Hello").unwrap();
-    model
-        .set_user_input(1, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
-        .unwrap();
-    model
-        .new_defined_name("myName", None, "Sheet1!$A$1")
-        .unwrap();
-
-    assert_eq!(
-        model.get_formatted_cell_value(1, 2, 1),
-        Ok("Hello world!".to_string())
-    );
-
-    model
-        .update_defined_name("myName", None, "myName", Some(0), "Sheet1!$A$1")
-        .unwrap();
-
-    assert_eq!(
-        model.get_formatted_cell_value(1, 2, 1),
-        Ok("#NAME?".to_string())
-    );
-}

base/src/test/user_model/test_delete_row_column_formatting.rs

@@ -1,243 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{
-    constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW},
-    expressions::types::Area,
-    UserModel,
-};
-
-#[test]
-fn delete_column_formatting() {
-    // We are going to delete formatting in column G (7)
-    // There are cells with their own styles
-    // There are rows with their own styles
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let cell_g123 = Area {
-        sheet: 0,
-        row: 123,
-        column: 7,
-        width: 1,
-        height: 1,
-    };
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_3_range = Area {
-        sheet: 0,
-        row: 3,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    // Set the style of the whole column
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    // Set G123 background to red
-    model
-        .update_range_style(&cell_g123, "fill.bg_color", "#FF5533")
-        .unwrap();
-
-    // Set the style of the whole row
-    model
-        .update_range_style(&row_3_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // Delete the column formatting
-    model.range_clear_formatting(&column_g_range).unwrap();
-
-    // Check the style of G123 is now what it was before
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-
-    // Check the style of the whole row is still there
-    let style = model.get_cell_style(0, 3, 1).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_owned()));
-
-    // Check the style of the whole column is now gone
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-
-    let style = model.get_cell_style(0, 40, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-
-    model.undo().unwrap();
-
-    // Check the style of G123 is now what it was before
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#FF5533".to_owned()));
-
-    // Check G3 is the row style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_owned()));
-
-    // Check G40 is the column style
-    let style = model.get_cell_style(0, 40, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_owned()));
-
-    model.redo().unwrap();
-
-    // Check the style of G123 is now what it was before
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-
-    // Check the style of the whole row is still there
-    let style = model.get_cell_style(0, 3, 1).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#333444".to_owned()));
-
-    // Check the style of the whole column is now gone
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-
-    let style = model.get_cell_style(0, 40, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-}
-
-#[test]
-fn column_width() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model
-        .set_columns_width(0, 7, 7, DEFAULT_COLUMN_WIDTH * 2.0)
-        .unwrap();
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    // Set the style of the whole column
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    // Delete the column formatting
-    model.range_clear_formatting(&column_g_range).unwrap();
-    // This does not change the column width
-    assert_eq!(
-        model.get_column_width(0, 7).unwrap(),
-        2.0 * DEFAULT_COLUMN_WIDTH
-    );
-
-    model.undo().unwrap();
-    assert_eq!(
-        model.get_column_width(0, 7).unwrap(),
-        2.0 * DEFAULT_COLUMN_WIDTH
-    );
-    model.redo().unwrap();
-    assert_eq!(
-        model.get_column_width(0, 7).unwrap(),
-        2.0 * DEFAULT_COLUMN_WIDTH
-    );
-}
-
-#[test]
-fn column_row_style_undo() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model
-        .set_columns_width(0, 7, 7, DEFAULT_COLUMN_WIDTH * 2.0)
-        .unwrap();
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_123_range = Area {
-        sheet: 0,
-        row: 123,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    let delete_range = Area {
-        sheet: 0,
-        row: 120,
-        column: 5,
-        width: 20,
-        height: 20,
-    };
-
-    // Set the style of the whole column
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    model
-        .update_range_style(&row_123_range, "fill.bg_color", "#111222")
-        .unwrap();
-
-    model.range_clear_formatting(&delete_range).unwrap();
-
-    // check G123 is empty
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-
-    // uno clear formatting
-    model.undo().unwrap();
-
-    // G123 has the row style
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#111222".to_owned()));
-
-    // undo twice
-    model.undo().unwrap();
-    model.undo().unwrap();
-
-    // check G123 is empty
-    let style = model.get_cell_style(0, 123, 7).unwrap();
-    assert_eq!(style.fill.bg_color, None);
-}
-
-#[test]
-fn column_row_row_height_undo() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    let row_3_range = Area {
-        sheet: 0,
-        row: 3,
-        column: 1,
-        width: LAST_COLUMN,
-        height: 1,
-    };
-
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#555666")
-        .unwrap();
-
-    model
-        .set_rows_height(0, 3, 3, DEFAULT_ROW_HEIGHT * 2.0)
-        .unwrap();
-
-    model
-        .update_range_style(&row_3_range, "fill.bg_color", "#111222")
-        .unwrap();
-
-    model.undo().unwrap();
-
-    // check G3 has the column style
-    let style = model.get_cell_style(0, 3, 7).unwrap();
-    assert_eq!(style.fill.bg_color, Some("#555666".to_string()));
-}

base/src/test/user_model/test_diff_queue.rs

@@ -10,7 +10,7 @@ use crate::{
 fn send_queue() {
     let mut model1 = UserModel::from_model(new_empty_model());
     let width = model1.get_column_width(0, 3).unwrap() * 3.0;
-    model1.set_columns_width(0, 3, 3, width).unwrap();
+    model1.set_column_width(0, 3, width).unwrap();
     model1.set_user_input(0, 1, 2, "Hello IronCalc!").unwrap();
     let send_queue = model1.flush_send_queue();
 
@@ -34,7 +34,7 @@ fn apply_external_diffs_wrong_str() {
 fn queue_undo_redo() {
     let mut model1 = UserModel::from_model(new_empty_model());
     let width = model1.get_column_width(0, 3).unwrap() * 3.0;
-    model1.set_columns_width(0, 3, 3, width).unwrap();
+    model1.set_column_width(0, 3, width).unwrap();
     model1.set_user_input(0, 1, 2, "Hello IronCalc!").unwrap();
     assert!(model1.undo().is_ok());
     assert!(model1.redo().is_ok());
@@ -57,8 +57,8 @@ fn queue_undo_redo_multiple() {
     // do a bunch of things
     model1.set_frozen_columns_count(0, 5).unwrap();
     model1.set_frozen_rows_count(0, 6).unwrap();
-    model1.set_columns_width(0, 7, 7, 300.0).unwrap();
+    model1.set_column_width(0, 7, 300.0).unwrap();
-    model1.set_rows_height(0, 23, 23, 123.0).unwrap();
+    model1.set_row_height(0, 23, 123.0).unwrap();
     model1.set_user_input(0, 55, 55, "=42+8").unwrap();
 
     for row in 1..5 {

base/src/test/user_model/test_general.rs

@@ -59,7 +59,7 @@ fn insert_remove_rows() {
     // Insert some data in row 5 (and change the style)
     assert!(model.set_user_input(0, 5, 1, "100$").is_ok());
     // Change the height of the column
-    assert!(model.set_rows_height(0, 5, 5, 3.0 * height).is_ok());
+    assert!(model.set_row_height(0, 5, 3.0 * height).is_ok());
 
     // remove the row
     assert!(model.delete_row(0, 5).is_ok());
@@ -95,7 +95,7 @@ fn insert_remove_columns() {
     // Insert some data in row 5 (and change the style) in E1
     assert!(model.set_user_input(0, 1, 5, "100$").is_ok());
     // Change the width of the column
-    assert!(model.set_columns_width(0, 5, 5, 3.0 * column_width).is_ok());
+    assert!(model.set_column_width(0, 5, 3.0 * column_width).is_ok());
     assert_eq!(model.get_column_width(0, 5).unwrap(), 3.0 * column_width);
 
     // remove the column

base/src/test/user_model/test_recursive.rs

@@ -1,42 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{
-    constants::LAST_ROW, expressions::types::Area, test::util::new_empty_model, UserModel,
-};
-
-#[test]
-fn two_columns() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Set style in column C (column 3)
-    let column_c_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 3,
-        width: 1,
-        height: LAST_ROW,
-    };
-    model
-        .update_range_style(&column_c_range, "fill.bg_color", "#333444")
-        .unwrap();
-    model.set_user_input(0, 5, 3, "2").unwrap();
-
-    // Set Style in column G (column 7)
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#333444")
-        .unwrap();
-    model.set_user_input(0, 5, 6, "42").unwrap();
-    // Set formula in G5: =F5*C5
-    model.set_user_input(0, 5, 7, "=F5*C5").unwrap();
-
-    assert_eq!(model.get_formatted_cell_value(0, 5, 7).unwrap(), "84");
-}

base/src/test/user_model/test_row_column.rs

@@ -59,7 +59,7 @@ fn simple_delete_column() {
     model.set_user_input(0, 1, 5, "3").unwrap();
     model.set_user_input(0, 2, 5, "=E1*2").unwrap();
     model
-        .set_columns_width(0, 5, 5, DEFAULT_COLUMN_WIDTH * 3.0)
+        .set_column_width(0, 5, DEFAULT_COLUMN_WIDTH * 3.0)
         .unwrap();
 
     model.delete_column(0, 5).unwrap();
@@ -116,7 +116,7 @@ fn simple_delete_row() {
     model.set_user_input(0, 15, 6, "=D15*2").unwrap();
 
     model
-        .set_rows_height(0, 15, 15, DEFAULT_ROW_HEIGHT * 3.0)
+        .set_row_height(0, 15, DEFAULT_ROW_HEIGHT * 3.0)
         .unwrap();
 
     model.delete_row(0, 15).unwrap();
@@ -172,42 +172,3 @@ fn row_heigh_increases_automatically() {
         .unwrap();
     assert_eq!(model.get_row_height(0, 1), Ok(2.0 * DEFAULT_ROW_HEIGHT));
 }
-
-#[test]
-fn insert_row_evaluates() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    model.set_user_input(0, 1, 1, "42").unwrap();
-    model.set_user_input(0, 1, 2, "=A1*2").unwrap();
-
-    assert!(model.insert_row(0, 1).is_ok());
-    assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
-
-    model.delete_row(0, 1).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
-    assert_eq!(model.get_cell_content(0, 1, 2).unwrap(), "=A1*2");
-}
-
-#[test]
-fn insert_column_evaluates() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    model.set_user_input(0, 1, 1, "42").unwrap();
-    model.set_user_input(0, 10, 1, "=A1*2").unwrap();
-
-    assert!(model.insert_column(0, 1).is_ok());
-    assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
-
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "84");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
-
-    model.delete_column(0, 1).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "84");
-    assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1*2");
-}

base/src/test/user_model/test_sheets_undo_redo.rs

@@ -1,52 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-use crate::UserModel;
-
-#[test]
-fn basic_undo_redo() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    assert_eq!(model.get_selected_sheet(), 0);
-
-    model.new_sheet().unwrap();
-    assert_eq!(model.get_selected_sheet(), 1);
-    model.undo().unwrap();
-    assert_eq!(model.get_selected_sheet(), 0);
-    {
-        let props = model.get_worksheets_properties();
-        assert_eq!(props.len(), 1);
-        let view = model.get_selected_view();
-        assert_eq!(view.sheet, 0);
-    }
-
-    model.redo().unwrap();
-    assert_eq!(model.get_selected_sheet(), 1);
-    {
-        let props = model.get_worksheets_properties();
-        assert_eq!(props.len(), 2);
-        let view = model.get_selected_view();
-
-        assert_eq!(view.sheet, 1);
-    }
-}
-
-#[test]
-fn delete_undo() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    assert_eq!(model.get_selected_sheet(), 0);
-
-    model.new_sheet().unwrap();
-    assert_eq!(model.get_selected_sheet(), 1);
-    model.set_user_input(1, 1, 1, "42").unwrap();
-    model.set_user_input(1, 1, 2, "=A1*2").unwrap();
-    model.delete_sheet(1).unwrap();
-
-    assert_eq!(model.get_selected_sheet(), 0);
-
-    model.undo().unwrap();
-    assert_eq!(model.get_selected_sheet(), 1);
-    model.redo().unwrap();
-    assert_eq!(model.get_selected_sheet(), 0);
-}

base/src/test/user_model/test_styles.rs

@@ -436,47 +436,3 @@ fn false_removes_value() {
     let style = model.get_cell_style(0, 1, 1).unwrap();
     assert!(!style.font.b);
 }
-
-#[test]
-fn cell_clear_formatting() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    // bold
-    model.update_range_style(&range, "font.b", "true").unwrap();
-    model
-        .update_range_style(&range, "alignment.horizontal", "centerContinuous")
-        .unwrap();
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert!(style.font.b);
-    assert_eq!(
-        style.alignment.unwrap().horizontal,
-        HorizontalAlignment::CenterContinuous
-    );
-
-    model.range_clear_all(&range).unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert!(!style.font.b);
-    assert_eq!(style.alignment, None);
-
-    model.undo().unwrap();
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert!(style.font.b);
-    assert_eq!(
-        style.alignment.unwrap().horizontal,
-        HorizontalAlignment::CenterContinuous
-    );
-    model.redo().unwrap();
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert!(!style.font.b);
-    assert_eq!(style.alignment, None);
-}

base/src/test/user_model/test_to_from_bytes.rs

@@ -6,7 +6,7 @@ use crate::{test::util::new_empty_model, UserModel};
 fn basic() {
     let mut model1 = UserModel::from_model(new_empty_model());
     let width = model1.get_column_width(0, 3).unwrap() * 3.0;
-    model1.set_columns_width(0, 3, 3, width).unwrap();
+    model1.set_column_width(0, 3, width).unwrap();
     model1.set_user_input(0, 1, 2, "Hello IronCalc!").unwrap();
 
     let model_bytes = model1.to_bytes();

base/src/types.rs

@@ -323,19 +323,6 @@ pub struct Style {
     pub quote_prefix: bool,
 }
 
-impl Default for Style {
-    fn default() -> Self {
-        Style {
-            alignment: None,
-            num_fmt: "general".to_string(),
-            fill: Fill::default(),
-            font: Font::default(),
-            border: Border::default(),
-            quote_prefix: false,
-        }
-    }
-}
-
 #[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct NumFmt {
     pub num_fmt_id: i32,
@@ -407,7 +394,7 @@ impl Default for Font {
             u: false,
             b: false,
             i: false,
-            sz: 13,
+            sz: 11,
             color: Some("#000000".to_string()),
             name: "Calibri".to_string(),
             family: 2,

base/src/units.rs

@@ -50,9 +50,8 @@ impl Units {
 fn get_units_from_format_string(num_fmt: &str) -> Option<Units> {
     let mut parser = Parser::new(num_fmt);
     parser.parse();
-    let parts = parser.parts.first()?;
     // We only care about the first part (positive number)
-    match parts {
+    match &parser.parts[0] {
         ParsePart::Number(part) => {
             if part.percent > 0 {
                 Some(Units::Percentage {

base/src/user_model/border.rs

@@ -1,507 +0,0 @@
-use crate::{
-    constants::{LAST_COLUMN, LAST_ROW},
-    expressions::types::Area,
-};
-
-use super::{
-    border_utils::is_max_border, common::BorderType, history::Diff, BorderArea, UserModel,
-};
-
-impl UserModel {
-    fn update_single_cell_border(
-        &mut self,
-        border_area: &BorderArea,
-        cell: (u32, i32, i32),
-        range: (i32, i32, i32, i32),
-        diff_list: &mut Vec<Diff>,
-    ) -> Result<(), String> {
-        let (sheet, row, column) = cell;
-        let (first_row, first_column, last_row, last_column) = range;
-
-        let old_value = self.model.get_cell_style_or_none(sheet, row, column)?;
-        let mut new_value = match &old_value {
-            Some(value) => value.clone(),
-            None => Default::default(),
-        };
-        match border_area.r#type {
-            BorderType::All => {
-                new_value.border.top = Some(border_area.item.clone());
-                new_value.border.right = Some(border_area.item.clone());
-                new_value.border.bottom = Some(border_area.item.clone());
-                new_value.border.left = Some(border_area.item.clone());
-            }
-            BorderType::Inner => {
-                if row != first_row {
-                    new_value.border.top = Some(border_area.item.clone());
-                }
-                if row != last_row {
-                    new_value.border.bottom = Some(border_area.item.clone());
-                }
-                if column != first_column {
-                    new_value.border.left = Some(border_area.item.clone());
-                }
-                if column != last_column {
-                    new_value.border.right = Some(border_area.item.clone());
-                }
-            }
-            BorderType::Outer => {
-                if row == first_row {
-                    new_value.border.top = Some(border_area.item.clone());
-                }
-                if row == last_row {
-                    new_value.border.bottom = Some(border_area.item.clone());
-                }
-                if column == first_column {
-                    new_value.border.left = Some(border_area.item.clone());
-                }
-                if column == last_column {
-                    new_value.border.right = Some(border_area.item.clone());
-                }
-            }
-            BorderType::Top => {
-                if row == first_row {
-                    new_value.border.top = Some(border_area.item.clone());
-                }
-            }
-            BorderType::Right => {
-                if column == last_column {
-                    new_value.border.right = Some(border_area.item.clone());
-                }
-            }
-            BorderType::Bottom => {
-                if row == last_row {
-                    new_value.border.bottom = Some(border_area.item.clone());
-                }
-            }
-            BorderType::Left => {
-                if column == first_column {
-                    new_value.border.left = Some(border_area.item.clone());
-                }
-            }
-            BorderType::CenterH => {
-                if row != first_row {
-                    new_value.border.top = Some(border_area.item.clone());
-                }
-                if row != last_row {
-                    new_value.border.bottom = Some(border_area.item.clone());
-                }
-            }
-            BorderType::CenterV => {
-                if column != first_column {
-                    new_value.border.left = Some(border_area.item.clone());
-                }
-                if column != last_column {
-                    new_value.border.right = Some(border_area.item.clone());
-                }
-            }
-            BorderType::None => {
-                new_value.border.top = None;
-                new_value.border.right = None;
-                new_value.border.bottom = None;
-                new_value.border.left = None;
-            }
-        }
-        self.model.set_cell_style(sheet, row, column, &new_value)?;
-        diff_list.push(Diff::SetCellStyle {
-            sheet,
-            row,
-            column,
-            old_value: Box::new(old_value),
-            new_value: Box::new(new_value),
-        });
-        Ok(())
-    }
-
-    fn set_rows_with_border(
-        &mut self,
-        sheet: u32,
-        first_row: i32,
-        last_row: i32,
-        border_area: &BorderArea,
-    ) -> Result<(), String> {
-        let mut diff_list = Vec::new();
-        for row in first_row..=last_row {
-            let old_value = self.model.get_row_style(sheet, row)?;
-            let mut new_value = match &old_value {
-                Some(value) => value.clone(),
-                None => Default::default(),
-            };
-
-            match border_area.r#type {
-                BorderType::All => {
-                    new_value.border.top = Some(border_area.item.clone());
-                    new_value.border.right = Some(border_area.item.clone());
-                    new_value.border.bottom = Some(border_area.item.clone());
-                    new_value.border.left = Some(border_area.item.clone());
-                }
-                BorderType::Inner => {
-                    if row != first_row {
-                        new_value.border.top = Some(border_area.item.clone());
-                    }
-                    if row != last_row {
-                        new_value.border.bottom = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Outer => {
-                    if row == first_row {
-                        new_value.border.top = Some(border_area.item.clone());
-                    }
-                    if row == last_row {
-                        new_value.border.bottom = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Top => {
-                    if row == first_row {
-                        new_value.border.top = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Right => {
-                    // noop
-                }
-                BorderType::Bottom => {
-                    if row == last_row {
-                        new_value.border.bottom = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Left => {
-                    // noop
-                }
-                BorderType::CenterH => {
-                    if row != first_row {
-                        new_value.border.top = Some(border_area.item.clone());
-                    }
-                    if row != last_row {
-                        new_value.border.bottom = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::CenterV => {
-                    new_value.border.left = Some(border_area.item.clone());
-                    new_value.border.right = Some(border_area.item.clone());
-                }
-                BorderType::None => {
-                    new_value.border.top = None;
-                    new_value.border.right = None;
-                    new_value.border.bottom = None;
-                    new_value.border.left = None;
-                }
-            }
-
-            // We need to go throw each non-empty cell in the row
-            let columns: Vec<i32> = self
-                .model
-                .workbook
-                .worksheet(sheet)?
-                .sheet_data
-                .get(&row)
-                .map(|row_data| row_data.keys().copied().collect())
-                .unwrap_or_default();
-            for column in columns {
-                self.update_single_cell_border(
-                    border_area,
-                    (sheet, row, column),
-                    (first_row, 1, last_row, LAST_COLUMN),
-                    &mut diff_list,
-                )?;
-            }
-
-            self.model.set_row_style(sheet, row, &new_value)?;
-            diff_list.push(Diff::SetRowStyle {
-                sheet,
-                row,
-                old_value: Box::new(old_value),
-                new_value: Box::new(new_value),
-            });
-        }
-        // TODO: We need to check the rows above and below. also any non empty cell in the rows above and below.
-        self.push_diff_list(diff_list);
-        Ok(())
-    }
-
-    fn set_columns_with_border(
-        &mut self,
-        sheet: u32,
-        first_column: i32,
-        last_column: i32,
-        border_area: &BorderArea,
-    ) -> Result<(), String> {
-        let mut diff_list = Vec::new();
-        // We need all the rows in the column to update the style
-        // NB: This is too much, this is all the rows that have values
-        let data_rows: Vec<i32> = self
-            .model
-            .workbook
-            .worksheet(sheet)?
-            .sheet_data
-            .keys()
-            .copied()
-            .collect();
-        let styled_rows = &self.model.workbook.worksheet(sheet)?.rows.clone();
-        for column in first_column..=last_column {
-            let old_value = self.model.get_column_style(sheet, column)?;
-            let mut new_value = match &old_value {
-                Some(value) => value.clone(),
-                None => Default::default(),
-            };
-
-            match border_area.r#type {
-                BorderType::All => {
-                    new_value.border.top = Some(border_area.item.clone());
-                    new_value.border.right = Some(border_area.item.clone());
-                    new_value.border.bottom = Some(border_area.item.clone());
-                    new_value.border.left = Some(border_area.item.clone());
-                }
-                BorderType::Inner => {
-                    if column != first_column {
-                        new_value.border.left = Some(border_area.item.clone());
-                    }
-                    if column != last_column {
-                        new_value.border.right = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Outer => {
-                    if column == first_column {
-                        new_value.border.left = Some(border_area.item.clone());
-                    }
-                    if column == last_column {
-                        new_value.border.right = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Top => {
-                    // noop
-                }
-                BorderType::Right => {
-                    if column == last_column {
-                        new_value.border.right = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::Bottom => {
-                    // noop
-                }
-                BorderType::Left => {
-                    if column == first_column {
-                        new_value.border.left = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::CenterH => {
-                    new_value.border.top = Some(border_area.item.clone());
-                    new_value.border.bottom = Some(border_area.item.clone());
-                }
-                BorderType::CenterV => {
-                    if column != first_column {
-                        new_value.border.left = Some(border_area.item.clone());
-                    }
-                    if column != last_column {
-                        new_value.border.right = Some(border_area.item.clone());
-                    }
-                }
-                BorderType::None => {
-                    new_value.border.top = None;
-                    new_value.border.right = None;
-                    new_value.border.bottom = None;
-                    new_value.border.left = None;
-                }
-            }
-            // We need to go through each non empty cell in the column
-            for &row in &data_rows {
-                if let Some(data_row) = self.model.workbook.worksheet(sheet)?.sheet_data.get(&row) {
-                    if data_row.get(&column).is_some() {
-                        self.update_single_cell_border(
-                            border_area,
-                            (sheet, row, column),
-                            (1, first_column, LAST_ROW, last_column),
-                            &mut diff_list,
-                        )?;
-                    }
-                }
-            }
-
-            // We also need to overwrite those that have a row style
-            for row_s in styled_rows.iter() {
-                let row = row_s.r;
-                self.update_single_cell_border(
-                    border_area,
-                    (sheet, row, column),
-                    (1, first_column, LAST_ROW, last_column),
-                    &mut diff_list,
-                )?;
-            }
-
-            self.model.set_column_style(sheet, column, &new_value)?;
-            diff_list.push(Diff::SetColumnStyle {
-                sheet,
-                column,
-                old_value: Box::new(old_value),
-                new_value: Box::new(new_value),
-            });
-        }
-        // We need to check the borders of the column to the left and the column to the right
-        // We also need to check every non-empty cell in the columns to the left and right
-        self.push_diff_list(diff_list);
-        Ok(())
-    }
-
-    /// Sets the border in an area of cells.
-    /// When setting the border we need to check if the adjacent cells have a "heavier" border
-    /// If that is the case we need to change it
-    pub fn set_area_with_border(
-        &mut self,
-        range: &Area,
-        border_area: &BorderArea,
-    ) -> Result<(), String> {
-        let sheet = range.sheet;
-        let first_row = range.row;
-        let first_column = range.column;
-        let last_row = first_row + range.height - 1;
-        let last_column = first_column + range.width - 1;
-        if first_row == 1 && last_row == LAST_ROW {
-            // full columns
-            self.set_columns_with_border(sheet, first_column, last_column, border_area)?;
-            return Ok(());
-        }
-        if first_column == 1 && last_column == LAST_COLUMN {
-            // full rows
-            self.set_rows_with_border(sheet, first_row, last_row, border_area)?;
-            return Ok(());
-        }
-        let mut diff_list = Vec::new();
-        for row in first_row..=last_row {
-            for column in first_column..=last_column {
-                self.update_single_cell_border(
-                    border_area,
-                    (sheet, row, column),
-                    (first_row, first_column, last_row, last_column),
-                    &mut diff_list,
-                )?;
-            }
-        }
-
-        // bottom of the cells above the first
-        if first_row > 1
-            && [
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-                BorderType::Top,
-            ]
-            .contains(&border_area.r#type)
-        {
-            let row = first_row - 1;
-            for column in first_column..=last_column {
-                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
-                if is_max_border(Some(&border_area.item), old_value.border.bottom.as_ref()) {
-                    let mut style = old_value.clone();
-                    if border_area.r#type == BorderType::None {
-                        style.border.bottom = None;
-                    } else {
-                        style.border.bottom = Some(border_area.item.clone());
-                    }
-                    self.model.set_cell_style(sheet, row, column, &style)?;
-                    diff_list.push(Diff::SetCellStyle {
-                        sheet,
-                        row,
-                        column,
-                        old_value: Box::new(Some(old_value)),
-                        new_value: Box::new(style),
-                    });
-                }
-            }
-        }
-        // Cells to the right
-        if last_column < LAST_COLUMN
-            && [
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-                BorderType::Right,
-            ]
-            .contains(&border_area.r#type)
-        {
-            let column = last_column + 1;
-            for row in first_row..=last_row {
-                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
-                // If the border in the adjacent cell is "heavier" we change it
-                if is_max_border(Some(&border_area.item), old_value.border.left.as_ref()) {
-                    let mut style = old_value.clone();
-                    if border_area.r#type == BorderType::None {
-                        style.border.left = None;
-                    } else {
-                        style.border.left = Some(border_area.item.clone());
-                    }
-                    self.model.set_cell_style(sheet, row, column, &style)?;
-                    diff_list.push(Diff::SetCellStyle {
-                        sheet,
-                        row,
-                        column,
-                        old_value: Box::new(Some(old_value)),
-                        new_value: Box::new(style),
-                    });
-                }
-            }
-        }
-        // Cells bellow
-        if last_row < LAST_ROW
-            && [
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-                BorderType::Bottom,
-            ]
-            .contains(&border_area.r#type)
-        {
-            let row = last_row + 1;
-            for column in first_column..=last_column {
-                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
-                if is_max_border(Some(&border_area.item), old_value.border.top.as_ref()) {
-                    let mut style = old_value.clone();
-                    if border_area.r#type == BorderType::None {
-                        style.border.top = None;
-                    } else {
-                        style.border.top = Some(border_area.item.clone());
-                    }
-                    self.model.set_cell_style(sheet, row, column, &style)?;
-                    diff_list.push(Diff::SetCellStyle {
-                        sheet,
-                        row,
-                        column,
-                        old_value: Box::new(Some(old_value)),
-                        new_value: Box::new(style),
-                    });
-                }
-            }
-        }
-        // Cells to the left
-        if first_column > 1
-            && [
-                BorderType::All,
-                BorderType::None,
-                BorderType::Outer,
-                BorderType::Left,
-            ]
-            .contains(&border_area.r#type)
-        {
-            let column = first_column - 1;
-            for row in first_row..=last_row {
-                let old_value = self.model.get_style_for_cell(sheet, row, column)?;
-                if is_max_border(Some(&border_area.item), old_value.border.right.as_ref()) {
-                    let mut style = old_value.clone();
-                    if border_area.r#type == BorderType::None {
-                        style.border.right = None;
-                    } else {
-                        style.border.right = Some(border_area.item.clone());
-                    }
-                    self.model.set_cell_style(sheet, row, column, &style)?;
-                    diff_list.push(Diff::SetCellStyle {
-                        sheet,
-                        row,
-                        column,
-                        old_value: Box::new(Some(old_value)),
-                        new_value: Box::new(style),
-                    });
-                }
-            }
-        }
-
-        self.push_diff_list(diff_list);
-        Ok(())
-    }
-}

base/src/user_model/history.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use bitcode::{Decode, Encode};
 
-use crate::types::{Cell, Col, Row, SheetState, Style, Worksheet};
+use crate::types::{Cell, Col, Row, SheetState, Style};
 
 #[derive(Clone, Encode, Decode)]
 pub(crate) struct RowData {
@@ -39,17 +39,11 @@ pub(crate) enum Diff {
         old_value: Box<Option<Cell>>,
         old_style: Box<Style>,
     },
-    CellClearFormatting {
-        sheet: u32,
-        row: i32,
-        column: i32,
-        old_style: Box<Option<Style>>,
-    },
     SetCellStyle {
         sheet: u32,
         row: i32,
         column: i32,
-        old_value: Box<Option<Style>>,
+        old_value: Box<Style>,
         new_value: Box<Style>,
     },
     // Column and Row diffs
@@ -65,28 +59,6 @@ pub(crate) enum Diff {
         new_value: f64,
         old_value: f64,
     },
-    SetColumnStyle {
-        sheet: u32,
-        column: i32,
-        old_value: Box<Option<Style>>,
-        new_value: Box<Style>,
-    },
-    SetRowStyle {
-        sheet: u32,
-        row: i32,
-        old_value: Box<Option<Style>>,
-        new_value: Box<Style>,
-    },
-    DeleteColumnStyle {
-        sheet: u32,
-        column: i32,
-        old_value: Box<Option<Style>>,
-    },
-    DeleteRowStyle {
-        sheet: u32,
-        row: i32,
-        old_value: Box<Option<Style>>,
-    },
     InsertRow {
         sheet: u32,
         row: i32,
@@ -105,10 +77,6 @@ pub(crate) enum Diff {
         column: i32,
         old_data: Box<ColumnData>,
     },
-    DeleteSheet {
-        sheet: u32,
-        old_data: Box<Worksheet>,
-    },
     SetFrozenRowsCount {
         sheet: u32,
         new_value: i32,
@@ -119,6 +87,9 @@ pub(crate) enum Diff {
         new_value: i32,
         old_value: i32,
     },
+    DeleteSheet {
+        sheet: u32,
+    },
     NewSheet {
         index: u32,
         name: String,
@@ -197,6 +168,11 @@ impl History {
             None => None,
         }
     }
+
+    pub fn clear(&mut self) {
+        self.redo_stack = vec![];
+        self.undo_stack = vec![];
+    }
 }
 
 #[derive(Clone, Encode, Decode)]

base/src/user_model/mod.rs

@@ -1,6 +1,5 @@
 #![deny(missing_docs)]
 
-mod border;
 mod border_utils;
 mod common;
 mod history;

base/src/workbook.rs

@@ -29,7 +29,7 @@ impl Workbook {
     }
 
     /// Returns the a list of defined names in the workbook with their scope
-    pub fn get_defined_names_with_scope(&self) -> Vec<(String, Option<u32>, String)> {
+    pub(crate) fn get_defined_names_with_scope(&self) -> Vec<(String, Option<u32>, String)> {
         let sheet_id_index: Vec<u32> = self.worksheets.iter().map(|s| s.sheet_id).collect();
 
         let defined_names = self

base/src/worksheet.rs

@@ -108,120 +108,37 @@ impl Worksheet {
         self.cols = vec![Col {
             min: 1,
             max: constants::LAST_COLUMN,
-            width: constants::DEFAULT_COLUMN_WIDTH,
+            width: constants::DEFAULT_COLUMN_WIDTH / constants::COLUMN_WIDTH_FACTOR,
-            custom_width: false,
+            custom_width: true,
             style: Some(style_index),
         }];
         Ok(())
     }
 
     pub fn set_column_style(&mut self, column: i32, style_index: i32) -> Result<(), String> {
-        let width = self
+        let width = constants::DEFAULT_COLUMN_WIDTH / constants::COLUMN_WIDTH_FACTOR;
-            .get_column_width(column)
-            .unwrap_or(constants::DEFAULT_COLUMN_WIDTH);
         self.set_column_width_and_style(column, width, Some(style_index))
     }
 
     pub fn set_row_style(&mut self, row: i32, style_index: i32) -> Result<(), String> {
-        // FIXME: This is a HACK
-        let custom_format = style_index != 0;
         for r in self.rows.iter_mut() {
             if r.r == row {
                 r.s = style_index;
-                r.custom_format = custom_format;
+                r.custom_format = true;
                 return Ok(());
             }
         }
         self.rows.push(Row {
             height: constants::DEFAULT_ROW_HEIGHT / constants::ROW_HEIGHT_FACTOR,
             r: row,
-            custom_format,
+            custom_format: true,
-            custom_height: false,
+            custom_height: true,
             s: style_index,
             hidden: false,
         });
         Ok(())
     }
 
-    pub fn delete_row_style(&mut self, row: i32) -> Result<(), String> {
-        let mut index = None;
-        for (i, r) in self.rows.iter().enumerate() {
-            if r.r == row {
-                index = Some(i);
-                break;
-            }
-        }
-        if let Some(i) = index {
-            if let Some(r) = self.rows.get_mut(i) {
-                r.s = 0;
-                r.custom_format = false;
-            }
-        }
-        Ok(())
-    }
-
-    pub fn delete_column_style(&mut self, column: i32) -> Result<(), String> {
-        if !is_valid_column_number(column) {
-            return Err(format!("Column number '{column}' is not valid."));
-        }
-        let cols = &mut self.cols;
-
-        let mut index = 0;
-        let mut split = false;
-        for c in cols.iter_mut() {
-            let min = c.min;
-            let max = c.max;
-            if min <= column && column <= max {
-                //
-                split = true;
-                break;
-            }
-            if column < min {
-                // We passed, there is nothing to delete
-                break;
-            }
-            index += 1;
-        }
-        if split {
-            let min = cols[index].min;
-            let max = cols[index].max;
-            let custom_width = cols[index].custom_width;
-            let width = cols[index].width;
-            let pre = Col {
-                min,
-                max: column - 1,
-                width,
-                custom_width,
-                style: cols[index].style,
-            };
-            let col = Col {
-                min: column,
-                max: column,
-                width,
-                custom_width,
-                style: None,
-            };
-            let post = Col {
-                min: column + 1,
-                max,
-                width,
-                custom_width,
-                style: cols[index].style,
-            };
-            cols.remove(index);
-            if column != max {
-                cols.insert(index, post);
-            }
-            if custom_width {
-                cols.insert(index, col);
-            }
-            if column != min {
-                cols.insert(index, pre);
-            }
-        }
-        Ok(())
-    }
-
     pub fn set_cell_style(
         &mut self,
         row: i32,
@@ -368,12 +285,11 @@ impl Worksheet {
 
     /// Changes the width of a column.
     ///   * If the column does not a have a width we simply add it
-    ///   * If it has, it might be part of a range and we need to split the range.
+    ///   * If it has, it might be part of a range and we ned to split the range.
     ///
     /// Fails if column index is outside allowed range or width is negative.
     pub fn set_column_width(&mut self, column: i32, width: f64) -> Result<(), String> {
-        let style = self.get_column_style(column)?;
+        self.set_column_width_and_style(column, width, None)
-        self.set_column_width_and_style(column, width, style)
     }
 
     pub(crate) fn set_column_width_and_style(
@@ -393,7 +309,7 @@ impl Worksheet {
             min: column,
             max: column,
             width: width / constants::COLUMN_WIDTH_FACTOR,
-            custom_width: width != constants::DEFAULT_COLUMN_WIDTH,
+            custom_width: true,
             style,
         };
         let mut index = 0;
@@ -403,9 +319,7 @@ impl Worksheet {
             let max = c.max;
             if min <= column && column <= max {
                 if min == column && max == column {
-                    c.style = style;
                     c.width = width / constants::COLUMN_WIDTH_FACTOR;
-                    c.custom_width = width != constants::DEFAULT_COLUMN_WIDTH;
                     return Ok(());
                 }
                 split = true;
@@ -469,23 +383,6 @@ impl Worksheet {
         Ok(constants::DEFAULT_COLUMN_WIDTH)
     }
 
-    /// Returns the column style index if present
-    pub fn get_column_style(&self, column: i32) -> Result<Option<i32>, String> {
-        if !is_valid_column_number(column) {
-            return Err(format!("Column number '{column}' is not valid."));
-        }
-
-        let cols = &self.cols;
-        for col in cols {
-            let min = col.min;
-            let max = col.max;
-            if column >= min && column <= max {
-                return Ok(col.style);
-            }
-        }
-        Ok(None)
-    }
-
     // Returns non empty cells in a column
     pub fn column_cell_references(&self, column: i32) -> Result<Vec<CellReferenceIndex>, String> {
         let mut column_cell_references: Vec<CellReferenceIndex> = Vec::new();

bindings/nodejs/.cargo/config.toml

@@ -1,5 +0,0 @@
-[target.aarch64-unknown-linux-musl]
-linker = "aarch64-linux-musl-gcc"
-rustflags = ["-C", "target-feature=-crt-static"]
-[target.x86_64-pc-windows-msvc]
-rustflags = ["-C", "target-feature=+crt-static"]

bindings/nodejs/.gitignore

@@ -1,197 +0,0 @@
-# Created by https://www.toptal.com/developers/gitignore/api/node
-# Edit at https://www.toptal.com/developers/gitignore?templates=node
-
-### Node ###
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-
-# Diagnostic reports (https://nodejs.org/api/report.html)
-report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-*.lcov
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-bower_components
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (https://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules/
-jspm_packages/
-
-# TypeScript v1 declaration files
-typings/
-
-# TypeScript cache
-*.tsbuildinfo
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Microbundle cache
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# dotenv environment variables file
-.env
-.env.test
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-
-# Next.js build output
-.next
-
-# Nuxt.js build / generate output
-.nuxt
-dist
-
-# Gatsby files
-.cache/
-# Comment in the public line in if your project uses Gatsby and not Next.js
-# https://nextjs.org/blog/next-9-1#public-directory-support
-# public
-
-# vuepress build output
-.vuepress/dist
-
-# Serverless directories
-.serverless/
-
-# FuseBox cache
-.fusebox/
-
-# DynamoDB Local files
-.dynamodb/
-
-# TernJS port file
-.tern-port
-
-# Stores VSCode versions used for testing VSCode extensions
-.vscode-test
-
-# End of https://www.toptal.com/developers/gitignore/api/node
-
-# Created by https://www.toptal.com/developers/gitignore/api/macos
-# Edit at https://www.toptal.com/developers/gitignore?templates=macos
-
-### macOS ###
-# General
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Icon must end with two 
-Icon
-
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-.com.apple.timemachine.donotpresent
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-### macOS Patch ###
-# iCloud generated files
-*.icloud
-
-# End of https://www.toptal.com/developers/gitignore/api/macos
-
-# Created by https://www.toptal.com/developers/gitignore/api/windows
-# Edit at https://www.toptal.com/developers/gitignore?templates=windows
-
-### Windows ###
-# Windows thumbnail cache files
-Thumbs.db
-Thumbs.db:encryptable
-ehthumbs.db
-ehthumbs_vista.db
-
-# Dump file
-*.stackdump
-
-# Folder config file
-[Dd]esktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
-
-# End of https://www.toptal.com/developers/gitignore/api/windows
-
-#Added by cargo
-
-/target
-Cargo.lock
-
-.pnp.*
-.yarn/*
-!.yarn/patches
-!.yarn/plugins
-!.yarn/releases
-!.yarn/sdks
-!.yarn/versions
-
-*.node

bindings/nodejs/.npmignore

@@ -1,13 +0,0 @@
-target
-Cargo.lock
-.cargo
-.github
-npm
-.eslintrc
-.prettierignore
-rustfmt.toml
-yarn.lock
-*.node
-.yarn
-__test__
-renovate.json

bindings/nodejs/.yarnrc.yml

@@ -1 +0,0 @@
-nodeLinker: node-modules

bindings/nodejs/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-edition = "2021"
-name = "ironcalc_nodejs"
-version = "0.3.1"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-# Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
-napi = { version = "2.12.2", default-features = false, features = ["napi4", "serde-json"] }
-napi-derive = "2.12.2"
-ironcalc = { path = "../../xlsx", version = "0.3.0" }
-serde = { version = "1.0", features = ["derive"] }
-
-[build-dependencies]
-napi-build = "2.0.1"
-

bindings/nodejs/README.md

@@ -1,18 +0,0 @@
-# IronCalc nodejs bindingds
-
-
-Example usage:
-
-```javascript
-import { Model } from '@ironcalc/wasm';
- 
-const model = new Model("Workbook1", "en", "UTC");
-
-model.setUserInput(0, 1, 1, "=1+1");
-const result1 = model.getFormattedCellValue(0, 1, 1);
-
-console.log('Cell value', result1);
-
-let result2 = model.getCellStyle(0, 1, 1);
-console.log('Cell style', result2);
-```

bindings/nodejs/__test__/index.spec.mjs

@@ -1,20 +0,0 @@
-import test from 'ava'
-
-import { UserModel, Model } from '../index.js';
- 
-test('User Model smoke test', (t) => {
-  const model = new UserModel("Workbook1", "en", "UTC");
-
-  model.setUserInput(0, 1, 1, "=1+1");
-  t.is(model.getFormattedCellValue(0, 1, 1), '2');
-});
-
-
-test('Raw API smoke test', (t) => {
-  const model = new Model("Workbook1", "en", "UTC");
-
-  model.setUserInput(0, 1, 1, "=1+1");
-  model.evaluate();
-  t.is(model.getFormattedCellValue(0, 1, 1), '2');
-});
-

bindings/nodejs/build.rs

@@ -1,5 +0,0 @@
-extern crate napi_build;
-
-fn main() {
-  napi_build::setup();
-}

bindings/nodejs/index.d.ts

@@ -1,115 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/* auto-generated by NAPI-RS */
-
-export declare class Model {
-  constructor(name: string, locale: string, timezone: string)
-  static fromXlsx(filePath: string, locale: string, tz: string): Model
-  static fromIcalc(fileName: string): Model
-  saveToXlsx(file: string): void
-  saveToIcalc(file: string): void
-  evaluate(): void
-  setUserInput(sheet: number, row: number, column: number, value: string): void
-  clearCellContents(sheet: number, row: number, column: number): void
-  getCellContent(sheet: number, row: number, column: number): string
-  getCellType(sheet: number, row: number, column: number): number
-  getFormattedCellValue(sheet: number, row: number, column: number): string
-  setCellStyle(sheet: number, row: number, column: number, style: unknown): void
-  getCellStyle(sheet: number, row: number, column: number): unknown
-  insertRows(sheet: number, row: number, rowCount: number): void
-  insertColumns(sheet: number, column: number, columnCount: number): void
-  deleteRows(sheet: number, row: number, rowCount: number): void
-  deleteColumns(sheet: number, column: number, columnCount: number): void
-  getColumnWidth(sheet: number, column: number): number
-  getRowHeight(sheet: number, row: number): number
-  setColumnWidth(sheet: number, column: number, width: number): void
-  setRowHeight(sheet: number, row: number, height: number): void
-  getFrozenColumnsCount(sheet: number): number
-  getFrozenRowsCount(sheet: number): number
-  setFrozenColumnsCount(sheet: number, columnCount: number): void
-  setFrozenRowsCount(sheet: number, rowCount: number): void
-  getWorksheetsProperties(): unknown
-  setSheetColor(sheet: number, color: string): void
-  addSheet(sheetName: string): void
-  newSheet(): void
-  deleteSheet(sheet: number): void
-  renameSheet(sheet: number, newName: string): void
-  getDefinedNameList(): unknown
-  newDefinedName(name: string, scope: number | undefined | null, formula: string): void
-  updateDefinedName(name: string, scope: number | undefined | null, newName: string, newScope: number | undefined | null, newFormula: string): void
-  deleteDefinedName(name: string, scope?: number | undefined | null): void
-  testPanic(): void
-}
-export declare class UserModel {
-  constructor(name: string, locale: string, timezone: string)
-  static fromBytes(bytes: Uint8Array): UserModel
-  canUndo(): boolean
-  canRedo(): boolean
-  pauseEvaluation(): void
-  resumeEvaluation(): void
-  flushSendQueue(): Array<number>
-  applyExternalDiffs(diffs: Uint8Array): void
-  getCellContent(sheet: number, row: number, column: number): string
-  newSheet(): void
-  deleteSheet(sheet: number): void
-  hideSheet(sheet: number): void
-  unhideSheet(sheet: number): void
-  renameSheet(sheet: number, name: string): void
-  setSheetColor(sheet: number, color: string): void
-  rangeClearAll(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
-  rangeClearContents(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
-  insertRow(sheet: number, row: number): void
-  insertColumn(sheet: number, column: number): void
-  deleteRow(sheet: number, row: number): void
-  deleteColumn(sheet: number, column: number): void
-  setRowHeight(sheet: number, row: number, height: number): void
-  setColumnWidth(sheet: number, column: number, width: number): void
-  getRowHeight(sheet: number, row: number): number
-  getColumnWidth(sheet: number, column: number): number
-  setUserInput(sheet: number, row: number, column: number, input: string): void
-  getFormattedCellValue(sheet: number, row: number, column: number): string
-  getFrozenRowsCount(sheet: number): number
-  getFrozenColumnsCount(sheet: number): number
-  setFrozenRowsCount(sheet: number, count: number): void
-  setFrozenColumnsCount(sheet: number, count: number): void
-  updateRangeStyle(range: unknown, stylePath: string, value: string): void
-  getCellStyle(sheet: number, row: number, column: number): unknown
-  onPasteStyles(styles: unknown): void
-  getCellType(sheet: number, row: number, column: number): number
-  getWorksheetsProperties(): unknown
-  getSelectedSheet(): number
-  getSelectedCell(): Array<number>
-  getSelectedView(): unknown
-  setSelectedSheet(sheet: number): void
-  setSelectedCell(row: number, column: number): void
-  setSelectedRange(startRow: number, startColumn: number, endRow: number, endColumn: number): void
-  setTopLeftVisibleCell(topRow: number, topColumn: number): void
-  setShowGridLines(sheet: number, showGridLines: boolean): void
-  getShowGridLines(sheet: number): boolean
-  autoFillRows(sourceArea: unknown, toRow: number): void
-  autoFillColumns(sourceArea: unknown, toColumn: number): void
-  onArrowRight(): void
-  onArrowLeft(): void
-  onArrowUp(): void
-  onArrowDown(): void
-  onPageDown(): void
-  onPageUp(): void
-  setWindowWidth(windowWidth: number): void
-  setWindowHeight(windowHeight: number): void
-  getScrollX(): number
-  getScrollY(): number
-  onExpandSelectedRange(key: string): void
-  onAreaSelecting(targetRow: number, targetColumn: number): void
-  setAreaWithBorder(area: unknown, borderArea: unknown): void
-  toBytes(): Array<number>
-  getName(): string
-  setName(name: string): void
-  copyToClipboard(): unknown
-  pasteFromClipboard(sourceSheet: number, sourceRange: unknown, clipboard: unknown, isCut: boolean): void
-  pasteCsvText(area: unknown, csv: string): void
-  getDefinedNameList(): unknown
-  newDefinedName(name: string, scope: number | undefined | null, formula: string): void
-  updateDefinedName(name: string, scope: number | undefined | null, newName: string, newScope: number | undefined | null, newFormula: string): void
-  deleteDefinedName(name: string, scope?: number | undefined | null): void
-}

bindings/nodejs/index.js

@@ -1,316 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
-
-/* auto-generated by NAPI-RS */
-
-const { existsSync, readFileSync } = require('fs')
-const { join } = require('path')
-
-const { platform, arch } = process
-
-let nativeBinding = null
-let localFileExisted = false
-let loadError = null
-
-function isMusl() {
-  // For Node 10
-  if (!process.report || typeof process.report.getReport !== 'function') {
-    try {
-      const lddPath = require('child_process').execSync('which ldd').toString().trim()
-      return readFileSync(lddPath, 'utf8').includes('musl')
-    } catch (e) {
-      return true
-    }
-  } else {
-    const { glibcVersionRuntime } = process.report.getReport().header
-    return !glibcVersionRuntime
-  }
-}
-
-switch (platform) {
-  case 'android':
-    switch (arch) {
-      case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'nodejs.android-arm64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.android-arm64.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-android-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm':
-        localFileExisted = existsSync(join(__dirname, 'nodejs.android-arm-eabi.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.android-arm-eabi.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-android-arm-eabi')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Android ${arch}`)
-    }
-    break
-  case 'win32':
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(
-          join(__dirname, 'nodejs.win32-x64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.win32-x64-msvc.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-win32-x64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'ia32':
-        localFileExisted = existsSync(
-          join(__dirname, 'nodejs.win32-ia32-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.win32-ia32-msvc.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-win32-ia32-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'nodejs.win32-arm64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.win32-arm64-msvc.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-win32-arm64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Windows: ${arch}`)
-    }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'nodejs.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./nodejs.darwin-universal.node')
-      } else {
-        nativeBinding = require('@ironcalc/nodejs-darwin-universal')
-      }
-      break
-    } catch {}
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'nodejs.darwin-x64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.darwin-x64.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-darwin-x64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'nodejs.darwin-arm64.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.darwin-arm64.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-darwin-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on macOS: ${arch}`)
-    }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
-    }
-    localFileExisted = existsSync(join(__dirname, 'nodejs.freebsd-x64.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./nodejs.freebsd-x64.node')
-      } else {
-        nativeBinding = require('@ironcalc/nodejs-freebsd-x64')
-      }
-    } catch (e) {
-      loadError = e
-    }
-    break
-  case 'linux':
-    switch (arch) {
-      case 'x64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-x64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-x64-musl.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-x64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-x64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-x64-gnu.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-x64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-arm64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-arm64-musl.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-arm64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-arm64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-arm64-gnu.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-arm64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-arm-musleabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-arm-musleabihf.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-arm-musleabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-arm-gnueabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-arm-gnueabihf.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-arm-gnueabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'riscv64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-riscv64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-riscv64-musl.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-riscv64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'nodejs.linux-riscv64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./nodejs.linux-riscv64-gnu.node')
-            } else {
-              nativeBinding = require('@ironcalc/nodejs-linux-riscv64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 's390x':
-        localFileExisted = existsSync(
-          join(__dirname, 'nodejs.linux-s390x-gnu.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./nodejs.linux-s390x-gnu.node')
-          } else {
-            nativeBinding = require('@ironcalc/nodejs-linux-s390x-gnu')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Linux: ${arch}`)
-    }
-    break
-  default:
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
-}
-
-if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
-  }
-  throw new Error(`Failed to load native binding`)
-}
-
-const { Model, UserModel } = nativeBinding
-
-module.exports.Model = Model
-module.exports.UserModel = UserModel

bindings/nodejs/main.mjs

@@ -1,28 +0,0 @@
-import { UserModel, Model } from './index.js'
-
-
-function testUserModel() {
-    const model = new UserModel("Workbook1", "en", "UTC");
-
-    model.setUserInput(0, 1, 1, "=1+1");
-    let t = model.getFormattedCellValue(0, 1, 1);
-
-    console.log('From native', t);
-
-    let t2 = model.getCellStyle(0, 1, 1);
-    console.log('From native', t2);
-}
-
-function testModel() {
-    const model = Model.fromXlsx("example.xlsx", "en", "UTC");
-    const style = model.getCellStyle(0, 1, 6);
-    console.log(style);
-
-    const quantum = model.getFormattedCellValue(0, 14, 4);
-    console.log(quantum);
-    
-}
-
-
-testUserModel();
-testModel();

bindings/nodejs/npm/android-arm-eabi/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-android-arm-eabi`
-
-This is the **armv7-linux-androideabi** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/android-arm-eabi/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-android-arm-eabi",
-  "version": "0.2.0",
-  "os": [
-    "android"
-  ],
-  "cpu": [
-    "arm"
-  ],
-  "main": "nodejs.android-arm-eabi.node",
-  "files": [
-    "nodejs.android-arm-eabi.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/android-arm64/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-android-arm64`
-
-This is the **aarch64-linux-android** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/android-arm64/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-android-arm64",
-  "version": "0.2.0",
-  "os": [
-    "android"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "main": "nodejs.android-arm64.node",
-  "files": [
-    "nodejs.android-arm64.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/darwin-arm64/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-darwin-arm64`
-
-This is the **aarch64-apple-darwin** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/darwin-arm64/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-darwin-arm64",
-  "version": "0.2.0",
-  "os": [
-    "darwin"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "main": "nodejs.darwin-arm64.node",
-  "files": [
-    "nodejs.darwin-arm64.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/darwin-universal/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-darwin-universal`
-
-This is the **universal-apple-darwin** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/darwin-universal/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-darwin-universal",
-  "version": "0.2.0",
-  "os": [
-    "darwin"
-  ],
-  "main": "nodejs.darwin-universal.node",
-  "files": [
-    "nodejs.darwin-universal.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/darwin-x64/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-darwin-x64`
-
-This is the **x86_64-apple-darwin** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/darwin-x64/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-darwin-x64",
-  "version": "0.2.0",
-  "os": [
-    "darwin"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "main": "nodejs.darwin-x64.node",
-  "files": [
-    "nodejs.darwin-x64.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/linux-arm-gnueabihf/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-arm-gnueabihf`
-
-This is the **armv7-unknown-linux-gnueabihf** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-arm-gnueabihf/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-arm-gnueabihf",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "arm"
-  ],
-  "main": "nodejs.linux-arm-gnueabihf.node",
-  "files": [
-    "nodejs.linux-arm-gnueabihf.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/linux-arm-musleabihf/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-arm-musleabihf`
-
-This is the **armv7-unknown-linux-musleabihf** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-arm-musleabihf/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-arm-musleabihf",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "arm"
-  ],
-  "main": "nodejs.linux-arm-musleabihf.node",
-  "files": [
-    "nodejs.linux-arm-musleabihf.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/linux-arm64-gnu/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-arm64-gnu`
-
-This is the **aarch64-unknown-linux-gnu** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-arm64-gnu/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-arm64-gnu",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "main": "nodejs.linux-arm64-gnu.node",
-  "files": [
-    "nodejs.linux-arm64-gnu.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  },
-  "libc": [
-    "glibc"
-  ]
-}

bindings/nodejs/npm/linux-arm64-musl/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-arm64-musl`
-
-This is the **aarch64-unknown-linux-musl** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-arm64-musl/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-arm64-musl",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "main": "nodejs.linux-arm64-musl.node",
-  "files": [
-    "nodejs.linux-arm64-musl.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  },
-  "libc": [
-    "musl"
-  ]
-}

bindings/nodejs/npm/linux-riscv64-gnu/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-riscv64-gnu`
-
-This is the **riscv64gc-unknown-linux-gnu** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-riscv64-gnu/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-riscv64-gnu",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "riscv64"
-  ],
-  "main": "nodejs.linux-riscv64-gnu.node",
-  "files": [
-    "nodejs.linux-riscv64-gnu.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  },
-  "libc": [
-    "glibc"
-  ]
-}

bindings/nodejs/npm/linux-x64-gnu/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-x64-gnu`
-
-This is the **x86_64-unknown-linux-gnu** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-x64-gnu/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-x64-gnu",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "main": "nodejs.linux-x64-gnu.node",
-  "files": [
-    "nodejs.linux-x64-gnu.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  },
-  "libc": [
-    "glibc"
-  ]
-}

bindings/nodejs/npm/linux-x64-musl/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-linux-x64-musl`
-
-This is the **x86_64-unknown-linux-musl** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/linux-x64-musl/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-linux-x64-musl",
-  "version": "0.2.0",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "main": "nodejs.linux-x64-musl.node",
-  "files": [
-    "nodejs.linux-x64-musl.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  },
-  "libc": [
-    "musl"
-  ]
-}

bindings/nodejs/npm/win32-arm64-msvc/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-win32-arm64-msvc`
-
-This is the **aarch64-pc-windows-msvc** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/win32-arm64-msvc/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-win32-arm64-msvc",
-  "version": "0.2.0",
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "main": "nodejs.win32-arm64-msvc.node",
-  "files": [
-    "nodejs.win32-arm64-msvc.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/npm/win32-x64-msvc/README.md

@@ -1,3 +0,0 @@
-# `@ironcalc/nodejs-win32-x64-msvc`
-
-This is the **x86_64-pc-windows-msvc** binary for `@ironcalc/nodejs`

bindings/nodejs/npm/win32-x64-msvc/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@ironcalc/nodejs-win32-x64-msvc",
-  "version": "0.2.0",
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "main": "nodejs.win32-x64-msvc.node",
-  "files": [
-    "nodejs.win32-x64-msvc.node"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">= 10"
-  }
-}

bindings/nodejs/package.json

@@ -1,44 +0,0 @@
-{
-  "name": "@ironcalc/nodejs",
-  "version": "0.3.1",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "napi": {
-    "name": "nodejs",
-    "triples": {
-      "additional": [
-        "aarch64-apple-darwin",
-        "aarch64-linux-android",
-        "aarch64-unknown-linux-gnu",
-        "aarch64-unknown-linux-musl",
-        "aarch64-pc-windows-msvc",
-        "armv7-unknown-linux-gnueabihf",
-        "armv7-unknown-linux-musleabihf",
-        "x86_64-unknown-linux-musl",
-        "armv7-linux-androideabi",
-        "universal-apple-darwin",
-        "riscv64gc-unknown-linux-gnu"
-      ]
-    }
-  },
-  "license": "MIT",
-  "devDependencies": {
-    "@napi-rs/cli": "^2.18.4",
-    "ava": "^6.0.1"
-  },
-  "ava": {
-    "timeout": "3m"
-  },
-  "engines": {
-    "node": ">= 10"
-  },
-  "scripts": {
-    "artifacts": "napi artifacts",
-    "build": "napi build --platform --release",
-    "build:debug": "napi build --platform",
-    "prepublishOnly": "napi prepublish -t npm",
-    "test": "ava",
-    "universal": "napi universal",
-    "version": "napi version"
-  }
-}

bindings/nodejs/rustfmt.toml

@@ -1,2 +0,0 @@
-tab_spaces = 2
-edition = "2021"

bindings/nodejs/src/lib.rs

@@ -1,8 +0,0 @@
-#[macro_use]
-extern crate napi_derive;
-
-mod model;
-mod user_model;
-
-pub use model::Model;
-pub use user_model::UserModel;

bindings/nodejs/src/model.rs

@@ -1,343 +0,0 @@
-#![deny(clippy::all)]
-
-use napi::{self, bindgen_prelude::*, JsUnknown, Result};
-use serde::Serialize;
-
-use ironcalc::{
-  base::{
-    types::{CellType, Style},
-    Model as BaseModel,
-  },
-  error::XlsxError,
-  export::{save_to_icalc, save_to_xlsx},
-  import::{load_from_icalc, load_from_xlsx},
-};
-
-#[derive(Serialize)]
-struct DefinedName {
-  name: String,
-  scope: Option<u32>,
-  formula: String,
-}
-
-fn to_js_error(error: String) -> Error {
-  Error::new(Status::Unknown, error)
-}
-
-fn to_node_error(error: XlsxError) -> Error {
-  Error::new(Status::Unknown, error.to_string())
-}
-
-#[napi]
-pub struct Model {
-  model: BaseModel,
-}
-
-#[napi]
-impl Model {
-  #[napi(constructor)]
-  pub fn new(name: String, locale: String, timezone: String) -> Result<Self> {
-    let model = BaseModel::new_empty(&name, &locale, &timezone).map_err(to_js_error)?;
-    Ok(Self { model })
-  }
-
-  #[napi(factory)]
-  pub fn from_xlsx(file_path: String, locale: String, tz: String) -> Result<Model> {
-    let model = load_from_xlsx(&file_path, &locale, &tz)
-      .map_err(|error| Error::new(Status::Unknown, error.to_string()))?;
-    Ok(Self { model })
-  }
-
-  #[napi(factory)]
-  pub fn from_icalc(file_name: String) -> Result<Model> {
-    let model = load_from_icalc(&file_name)
-      .map_err(|error| Error::new(Status::Unknown, error.to_string()))?;
-    Ok(Self { model })
-  }
-
-  #[napi]
-  pub fn save_to_xlsx(&self, file: String) -> Result<()> {
-    save_to_xlsx(&self.model, &file).map_err(to_node_error)
-  }
-
-  #[napi]
-  pub fn save_to_icalc(&self, file: String) -> Result<()> {
-    save_to_icalc(&self.model, &file).map_err(to_node_error)
-  }
-
-  #[napi]
-  pub fn evaluate(&mut self) {
-    self.model.evaluate();
-  }
-
-  #[napi]
-  pub fn set_user_input(&mut self, sheet: u32, row: i32, column: i32, value: String) -> Result<()> {
-    self
-      .model
-      .set_user_input(sheet, row, column, value)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn clear_cell_contents(&mut self, sheet: u32, row: i32, column: i32) -> Result<()> {
-    self
-      .model
-      .cell_clear_contents(sheet, row, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn get_cell_content(&self, sheet: u32, row: i32, column: i32) -> Result<String> {
-    self
-      .model
-      .get_cell_content(sheet, row, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getCellType")]
-  pub fn get_cell_type(&self, sheet: u32, row: i32, column: i32) -> Result<i32> {
-    Ok(
-      match self
-        .model
-        .get_cell_type(sheet, row, column)
-        .map_err(to_js_error)?
-      {
-        CellType::Number => 1,
-        CellType::Text => 2,
-        CellType::LogicalValue => 4,
-        CellType::ErrorValue => 16,
-        CellType::Array => 64,
-        CellType::CompoundData => 128,
-      },
-    )
-  }
-
-  #[napi]
-  pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> Result<String> {
-    self
-      .model
-      .get_formatted_cell_value(sheet, row, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn set_cell_style(
-    &mut self,
-    env: Env,
-    sheet: u32,
-    row: i32,
-    column: i32,
-    style: JsUnknown,
-  ) -> Result<()> {
-    let style: Style = env
-      .from_js_value(style)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .set_cell_style(sheet, row, column, &style)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getCellStyle")]
-  pub fn get_cell_style(
-    &mut self,
-    env: Env,
-    sheet: u32,
-    row: i32,
-    column: i32,
-  ) -> Result<JsUnknown> {
-    let style = self
-      .model
-      .get_style_for_cell(sheet, row, column)
-      .map_err(to_js_error)?;
-
-    env
-      .to_js_value(&style)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi]
-  pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<()> {
-    self
-      .model
-      .insert_rows(sheet, row, row_count)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn insert_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> Result<()> {
-    self
-      .model
-      .insert_columns(sheet, column, column_count)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<()> {
-    self
-      .model
-      .delete_rows(sheet, row, row_count)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn delete_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> Result<()> {
-    self
-      .model
-      .delete_columns(sheet, column, column_count)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn get_column_width(&self, sheet: u32, column: i32) -> Result<f64> {
-    self
-      .model
-      .get_column_width(sheet, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn get_row_height(&self, sheet: u32, row: i32) -> Result<f64> {
-    self.model.get_row_height(sheet, row).map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn set_column_width(&mut self, sheet: u32, column: i32, width: f64) -> Result<()> {
-    self
-      .model
-      .set_column_width(sheet, column, width)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn set_row_height(&mut self, sheet: u32, row: i32, height: f64) -> Result<()> {
-    self
-      .model
-      .set_row_height(sheet, row, height)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn get_frozen_columns_count(&self, sheet: u32) -> Result<i32> {
-    self
-      .model
-      .get_frozen_columns_count(sheet)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn get_frozen_rows_count(&self, sheet: u32) -> Result<i32> {
-    self.model.get_frozen_rows_count(sheet).map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn set_frozen_columns_count(&mut self, sheet: u32, column_count: i32) -> Result<()> {
-    self
-      .model
-      .set_frozen_columns(sheet, column_count)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn set_frozen_rows_count(&mut self, sheet: u32, row_count: i32) -> Result<()> {
-    self
-      .model
-      .set_frozen_rows(sheet, row_count)
-      .map_err(to_js_error)
-  }
-
-  // I don't _think_ serializing to JsUnknown can't fail
-  // FIXME: Remove this clippy directive
-  #[napi(js_name = "getWorksheetsProperties")]
-  #[allow(clippy::unwrap_used)]
-  pub fn get_worksheets_properties(&self, env: Env) -> JsUnknown {
-    env
-      .to_js_value(&self.model.get_worksheets_properties())
-      .unwrap()
-  }
-
-  #[napi]
-  pub fn set_sheet_color(&mut self, sheet: u32, color: String) -> Result<()> {
-    self
-      .model
-      .set_sheet_color(sheet, &color)
-      .map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn add_sheet(&mut self, sheet_name: String) -> Result<()> {
-    self.model.add_sheet(&sheet_name).map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn new_sheet(&mut self) {
-    self.model.new_sheet();
-  }
-
-  #[napi]
-  pub fn delete_sheet(&mut self, sheet: u32) -> Result<()> {
-    self.model.delete_sheet(sheet).map_err(to_js_error)
-  }
-
-  #[napi]
-  pub fn rename_sheet(&mut self, sheet: u32, new_name: String) -> Result<()> {
-    self
-      .model
-      .rename_sheet_by_index(sheet, &new_name)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getDefinedNameList")]
-  pub fn get_defined_name_list(&self, env: Env) -> Result<JsUnknown> {
-    let data: Vec<DefinedName> = self
-      .model
-      .workbook
-      .get_defined_names_with_scope()
-      .iter()
-      .map(|s| DefinedName {
-        name: s.0.to_owned(),
-        scope: s.1,
-        formula: s.2.to_owned(),
-      })
-      .collect();
-    env
-      .to_js_value(&data)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "newDefinedName")]
-  pub fn new_defined_name(
-    &mut self,
-    name: String,
-    scope: Option<u32>,
-    formula: String,
-  ) -> Result<()> {
-    self
-      .model
-      .new_defined_name(&name, scope, &formula)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "updateDefinedName")]
-  pub fn update_defined_name(
-    &mut self,
-    name: String,
-    scope: Option<u32>,
-    new_name: String,
-    new_scope: Option<u32>,
-    new_formula: String,
-  ) -> Result<()> {
-    self
-      .model
-      .update_defined_name(&name, scope, &new_name, new_scope, &new_formula)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "deleteDefinedName")]
-  pub fn delete_definedname(&mut self, name: String, scope: Option<u32>) -> Result<()> {
-    self
-      .model
-      .delete_defined_name(&name, scope)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-}

bindings/nodejs/src/user_model.rs

@@ -1,654 +0,0 @@
-#![deny(clippy::all)]
-
-use serde::Serialize;
-
-use napi::{self, bindgen_prelude::*, JsUnknown, Result};
-
-use ironcalc::base::{
-  expressions::types::Area,
-  types::{CellType, Style},
-  BorderArea, ClipboardData, UserModel as BaseModel,
-};
-
-#[derive(Serialize)]
-struct DefinedName {
-  name: String,
-  scope: Option<u32>,
-  formula: String,
-}
-
-fn to_js_error(error: String) -> Error {
-  Error::new(Status::Unknown, error)
-}
-
-#[napi]
-pub struct UserModel {
-  model: BaseModel,
-}
-
-#[napi]
-impl UserModel {
-  #[napi(constructor)]
-  pub fn new(name: String, locale: String, timezone: String) -> Result<Self> {
-    let model = BaseModel::new_empty(&name, &locale, &timezone).map_err(to_js_error)?;
-    Ok(Self { model })
-  }
-
-  #[napi(factory)]
-  pub fn from_bytes(bytes: &[u8]) -> Result<UserModel> {
-    let model = BaseModel::from_bytes(bytes).map_err(to_js_error)?;
-    Ok(UserModel { model })
-  }
-
-  pub fn undo(&mut self) -> Result<()> {
-    self.model.undo().map_err(to_js_error)
-  }
-
-  pub fn redo(&mut self) -> Result<()> {
-    self.model.redo().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "canUndo")]
-  pub fn can_undo(&self) -> bool {
-    self.model.can_undo()
-  }
-
-  #[napi(js_name = "canRedo")]
-  pub fn can_redo(&self) -> bool {
-    self.model.can_redo()
-  }
-
-  #[napi(js_name = "pauseEvaluation")]
-  pub fn pause_evaluation(&mut self) {
-    self.model.pause_evaluation()
-  }
-
-  #[napi(js_name = "resumeEvaluation")]
-  pub fn resume_evaluation(&mut self) {
-    self.model.resume_evaluation()
-  }
-
-  pub fn evaluate(&mut self) {
-    self.model.evaluate();
-  }
-
-  #[napi(js_name = "flushSendQueue")]
-  pub fn flush_send_queue(&mut self) -> Vec<u8> {
-    self.model.flush_send_queue()
-  }
-
-  #[napi(js_name = "applyExternalDiffs")]
-  pub fn apply_external_diffs(&mut self, diffs: &[u8]) -> Result<()> {
-    self.model.apply_external_diffs(diffs).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getCellContent")]
-  pub fn get_cell_content(&self, sheet: u32, row: i32, column: i32) -> Result<String> {
-    self
-      .model
-      .get_cell_content(sheet, row, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "newSheet")]
-  pub fn new_sheet(&mut self) -> Result<()> {
-    self.model.new_sheet().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "deleteSheet")]
-  pub fn delete_sheet(&mut self, sheet: u32) -> Result<()> {
-    self.model.delete_sheet(sheet).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "hideSheet")]
-  pub fn hide_sheet(&mut self, sheet: u32) -> Result<()> {
-    self.model.hide_sheet(sheet).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "unhideSheet")]
-  pub fn unhide_sheet(&mut self, sheet: u32) -> Result<()> {
-    self.model.unhide_sheet(sheet).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "renameSheet")]
-  pub fn rename_sheet(&mut self, sheet: u32, name: String) -> Result<()> {
-    self.model.rename_sheet(sheet, &name).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setSheetColor")]
-  pub fn set_sheet_color(&mut self, sheet: u32, color: String) -> Result<()> {
-    self
-      .model
-      .set_sheet_color(sheet, &color)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "rangeClearAll")]
-  pub fn range_clear_all(
-    &mut self,
-    sheet: u32,
-    start_row: i32,
-    start_column: i32,
-    end_row: i32,
-    end_column: i32,
-  ) -> Result<()> {
-    let range = Area {
-      sheet,
-      row: start_row,
-      column: start_column,
-      width: end_column - start_column + 1,
-      height: end_row - start_row + 1,
-    };
-    self.model.range_clear_all(&range).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "rangeClearContents")]
-  pub fn range_clear_contents(
-    &mut self,
-    sheet: u32,
-    start_row: i32,
-    start_column: i32,
-    end_row: i32,
-    end_column: i32,
-  ) -> Result<()> {
-    let range = Area {
-      sheet,
-      row: start_row,
-      column: start_column,
-      width: end_column - start_column + 1,
-      height: end_row - start_row + 1,
-    };
-    self.model.range_clear_contents(&range).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "rangeClearFormatting")]
-  pub fn range_clear_formatting(
-    &mut self,
-    sheet: u32,
-    start_row: i32,
-    start_column: i32,
-    end_row: i32,
-    end_column: i32,
-  ) -> Result<()> {
-    let range = Area {
-      sheet,
-      row: start_row,
-      column: start_column,
-      width: end_column - start_column + 1,
-      height: end_row - start_row + 1,
-    };
-    self
-      .model
-      .range_clear_formatting(&range)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "insertRow")]
-  pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<()> {
-    self.model.insert_row(sheet, row).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "insertColumn")]
-  pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<()> {
-    self.model.insert_column(sheet, column).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "deleteRow")]
-  pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<()> {
-    self.model.delete_row(sheet, row).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "deleteColumn")]
-  pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<()> {
-    self.model.delete_column(sheet, column).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setRowsHeight")]
-  pub fn set_rows_height(
-    &mut self,
-    sheet: u32,
-    row_start: i32,
-    row_end: i32,
-    height: f64,
-  ) -> Result<()> {
-    self
-      .model
-      .set_rows_height(sheet, row_start, row_end, height)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setColumnsWidth")]
-  pub fn set_columns_width(
-    &mut self,
-    sheet: u32,
-    column_start: i32,
-    column_end: i32,
-    width: f64,
-  ) -> Result<()> {
-    self
-      .model
-      .set_columns_width(sheet, column_start, column_end, width)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getRowHeight")]
-  pub fn get_row_height(&mut self, sheet: u32, row: i32) -> Result<f64> {
-    self.model.get_row_height(sheet, row).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getColumnWidth")]
-  pub fn get_column_width(&mut self, sheet: u32, column: i32) -> Result<f64> {
-    self
-      .model
-      .get_column_width(sheet, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setUserInput")]
-  pub fn set_user_input(&mut self, sheet: u32, row: i32, column: i32, input: String) -> Result<()> {
-    self
-      .model
-      .set_user_input(sheet, row, column, &input)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getFormattedCellValue")]
-  pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> Result<String> {
-    self
-      .model
-      .get_formatted_cell_value(sheet, row, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getFrozenRowsCount")]
-  pub fn get_frozen_rows_count(&self, sheet: u32) -> Result<i32> {
-    self.model.get_frozen_rows_count(sheet).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getFrozenColumnsCount")]
-  pub fn get_frozen_columns_count(&self, sheet: u32) -> Result<i32> {
-    self
-      .model
-      .get_frozen_columns_count(sheet)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setFrozenRowsCount")]
-  pub fn set_frozen_rows_count(&mut self, sheet: u32, count: i32) -> Result<()> {
-    self
-      .model
-      .set_frozen_rows_count(sheet, count)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setFrozenColumnsCount")]
-  pub fn set_frozen_columns_count(&mut self, sheet: u32, count: i32) -> Result<()> {
-    self
-      .model
-      .set_frozen_columns_count(sheet, count)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "updateRangeStyle")]
-  pub fn update_range_style(
-    &mut self,
-    env: Env,
-    range: JsUnknown,
-    style_path: String,
-    value: String,
-  ) -> Result<()> {
-    let range: Area = env
-      .from_js_value(range)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .update_range_style(&range, &style_path, &value)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getCellStyle")]
-  pub fn get_cell_style(
-    &mut self,
-    env: Env,
-    sheet: u32,
-    row: i32,
-    column: i32,
-  ) -> Result<JsUnknown> {
-    let style = self
-      .model
-      .get_cell_style(sheet, row, column)
-      .map_err(to_js_error)?;
-
-    env
-      .to_js_value(&style)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "onPasteStyles")]
-  pub fn on_paste_styles(&mut self, env: Env, styles: JsUnknown) -> Result<()> {
-    let styles: &Vec<Vec<Style>> = &env
-      .from_js_value(styles)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self.model.on_paste_styles(styles).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getCellType")]
-  pub fn get_cell_type(&self, sheet: u32, row: i32, column: i32) -> Result<i32> {
-    Ok(
-      match self
-        .model
-        .get_cell_type(sheet, row, column)
-        .map_err(to_js_error)?
-      {
-        CellType::Number => 1,
-        CellType::Text => 2,
-        CellType::LogicalValue => 4,
-        CellType::ErrorValue => 16,
-        CellType::Array => 64,
-        CellType::CompoundData => 128,
-      },
-    )
-  }
-
-  // I don't _think_ serializing to JsUnknown can't fail
-  // FIXME: Remove this clippy directive
-  #[napi(js_name = "getWorksheetsProperties")]
-  #[allow(clippy::unwrap_used)]
-  pub fn get_worksheets_properties(&self, env: Env) -> JsUnknown {
-    env
-      .to_js_value(&self.model.get_worksheets_properties())
-      .unwrap()
-  }
-
-  #[napi(js_name = "getSelectedSheet")]
-  pub fn get_selected_sheet(&self) -> u32 {
-    self.model.get_selected_sheet()
-  }
-
-  #[napi(js_name = "getSelectedCell")]
-  pub fn get_selected_cell(&self) -> Vec<i32> {
-    let (sheet, row, column) = self.model.get_selected_cell();
-    vec![sheet as i32, row, column]
-  }
-
-  // I don't _think_ serializing to JsUnknown can't fail
-  // FIXME: Remove this clippy directive
-  #[napi(js_name = "getSelectedView")]
-  #[allow(clippy::unwrap_used)]
-  pub fn get_selected_view(&self, env: Env) -> JsUnknown {
-    env.to_js_value(&self.model.get_selected_view()).unwrap()
-  }
-
-  #[napi(js_name = "setSelectedSheet")]
-  pub fn set_selected_sheet(&mut self, sheet: u32) -> Result<()> {
-    self.model.set_selected_sheet(sheet).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setSelectedCell")]
-  pub fn set_selected_cell(&mut self, row: i32, column: i32) -> Result<()> {
-    self
-      .model
-      .set_selected_cell(row, column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setSelectedRange")]
-  pub fn set_selected_range(
-    &mut self,
-    start_row: i32,
-    start_column: i32,
-    end_row: i32,
-    end_column: i32,
-  ) -> Result<()> {
-    self
-      .model
-      .set_selected_range(start_row, start_column, end_row, end_column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setTopLeftVisibleCell")]
-  pub fn set_top_left_visible_cell(&mut self, top_row: i32, top_column: i32) -> Result<()> {
-    self
-      .model
-      .set_top_left_visible_cell(top_row, top_column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setShowGridLines")]
-  pub fn set_show_grid_lines(&mut self, sheet: u32, show_grid_lines: bool) -> Result<()> {
-    self
-      .model
-      .set_show_grid_lines(sheet, show_grid_lines)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getShowGridLines")]
-  pub fn get_show_grid_lines(&mut self, sheet: u32) -> Result<bool> {
-    self.model.get_show_grid_lines(sheet).map_err(to_js_error)
-  }
-
-  #[napi(js_name = "autoFillRows")]
-  pub fn auto_fill_rows(&mut self, env: Env, source_area: JsUnknown, to_row: i32) -> Result<()> {
-    let area: Area = env
-      .from_js_value(source_area)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .auto_fill_rows(&area, to_row)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "autoFillColumns")]
-  pub fn auto_fill_columns(
-    &mut self,
-    env: Env,
-    source_area: JsUnknown,
-    to_column: i32,
-  ) -> Result<()> {
-    let area: Area = env
-      .from_js_value(source_area)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .auto_fill_columns(&area, to_column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onArrowRight")]
-  pub fn on_arrow_right(&mut self) -> Result<()> {
-    self.model.on_arrow_right().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onArrowLeft")]
-  pub fn on_arrow_left(&mut self) -> Result<()> {
-    self.model.on_arrow_left().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onArrowUp")]
-  pub fn on_arrow_up(&mut self) -> Result<()> {
-    self.model.on_arrow_up().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onArrowDown")]
-  pub fn on_arrow_down(&mut self) -> Result<()> {
-    self.model.on_arrow_down().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onPageDown")]
-  pub fn on_page_down(&mut self) -> Result<()> {
-    self.model.on_page_down().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onPageUp")]
-  pub fn on_page_up(&mut self) -> Result<()> {
-    self.model.on_page_up().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setWindowWidth")]
-  pub fn set_window_width(&mut self, window_width: f64) {
-    self.model.set_window_width(window_width);
-  }
-
-  #[napi(js_name = "setWindowHeight")]
-  pub fn set_window_height(&mut self, window_height: f64) {
-    self.model.set_window_height(window_height);
-  }
-
-  #[napi(js_name = "getScrollX")]
-  pub fn get_scroll_x(&self) -> Result<f64> {
-    self.model.get_scroll_x().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "getScrollY")]
-  pub fn get_scroll_y(&self) -> Result<f64> {
-    self.model.get_scroll_y().map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onExpandSelectedRange")]
-  pub fn on_expand_selected_range(&mut self, key: String) -> Result<()> {
-    self
-      .model
-      .on_expand_selected_range(&key)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "onAreaSelecting")]
-  pub fn on_area_selecting(&mut self, target_row: i32, target_column: i32) -> Result<()> {
-    self
-      .model
-      .on_area_selecting(target_row, target_column)
-      .map_err(to_js_error)
-  }
-
-  #[napi(js_name = "setAreaWithBorder")]
-  pub fn set_area_with_border(
-    &mut self,
-    env: Env,
-    area: JsUnknown,
-    border_area: JsUnknown,
-  ) -> Result<()> {
-    let range: Area = env
-      .from_js_value(area)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    let border: BorderArea = env
-      .from_js_value(border_area)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .set_area_with_border(&range, &border)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    Ok(())
-  }
-
-  #[napi(js_name = "toBytes")]
-  pub fn to_bytes(&self) -> Vec<u8> {
-    self.model.to_bytes()
-  }
-
-  #[napi(js_name = "getName")]
-  pub fn get_name(&self) -> String {
-    self.model.get_name()
-  }
-
-  #[napi(js_name = "setName")]
-  pub fn set_name(&mut self, name: String) {
-    self.model.set_name(&name);
-  }
-
-  #[napi(js_name = "copyToClipboard")]
-  pub fn copy_to_clipboard(&self, env: Env) -> Result<JsUnknown> {
-    let data = self
-      .model
-      .copy_to_clipboard()
-      .map_err(|e| to_js_error(e.to_string()))?;
-
-    env
-      .to_js_value(&data)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "pasteFromClipboard")]
-  pub fn paste_from_clipboard(
-    &mut self,
-    env: Env,
-    source_sheet: u32,
-    source_range: JsUnknown,
-    clipboard: JsUnknown,
-    is_cut: bool,
-  ) -> Result<()> {
-    let source_range: (i32, i32, i32, i32) = env
-      .from_js_value(source_range)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    let clipboard: ClipboardData = env
-      .from_js_value(clipboard)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .paste_from_clipboard(source_sheet, source_range, &clipboard, is_cut)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "pasteCsvText")]
-  pub fn paste_csv_string(&mut self, env: Env, area: JsUnknown, csv: String) -> Result<()> {
-    let range: Area = env
-      .from_js_value(area)
-      .map_err(|e| to_js_error(e.to_string()))?;
-    self
-      .model
-      .paste_csv_string(&range, &csv)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "getDefinedNameList")]
-  pub fn get_defined_name_list(&self, env: Env) -> Result<JsUnknown> {
-    let data: Vec<DefinedName> = self
-      .model
-      .get_defined_name_list()
-      .iter()
-      .map(|s| DefinedName {
-        name: s.0.to_owned(),
-        scope: s.1,
-        formula: s.2.to_owned(),
-      })
-      .collect();
-    env
-      .to_js_value(&data)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "newDefinedName")]
-  pub fn new_defined_name(
-    &mut self,
-    name: String,
-    scope: Option<u32>,
-    formula: String,
-  ) -> Result<()> {
-    self
-      .model
-      .new_defined_name(&name, scope, &formula)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "updateDefinedName")]
-  pub fn update_defined_name(
-    &mut self,
-    name: String,
-    scope: Option<u32>,
-    new_name: String,
-    new_scope: Option<u32>,
-    new_formula: String,
-  ) -> Result<()> {
-    self
-      .model
-      .update_defined_name(&name, scope, &new_name, new_scope, &new_formula)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-
-  #[napi(js_name = "deleteDefinedName")]
-  pub fn delete_definedname(&mut self, name: String, scope: Option<u32>) -> Result<()> {
-    self
-      .model
-      .delete_defined_name(&name, scope)
-      .map_err(|e| to_js_error(e.to_string()))
-  }
-}

bindings/python/Cargo.lock

@@ -0,0 +1,884 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bumpalo"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bzip2"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8"
+dependencies = [
+ "bzip2-sys",
+ "libc",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.11+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbc529705a6e0028189c83f0a5dd9fb214105116f7e3c0eeab7ff0369766b0d1"
+dependencies = [
+ "chrono",
+ "chrono-tz-build",
+ "phf",
+]
+
+[[package]]
+name = "chrono-tz-build"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9998fb9f7e9b2111641485bf8beb32f92945f97f92a3d061f744cfef335f751"
+dependencies = [
+ "parse-zoneinfo",
+ "phf",
+ "phf_codegen",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "flate2"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe9006bed769170c11f845cf00c7c1e9092aeb3f268e007c3e760ac68008070f"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8326b86b6cff230b97d0d312a6c40a60726df3332e721f72a1b035f451663b20"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "indoc"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "ironcalc"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "ironcalc_base",
+ "itertools",
+ "roxmltree",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "zip",
+]
+
+[[package]]
+name = "ironcalc_base"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "chrono-tz",
+ "js-sys",
+ "once_cell",
+ "rand",
+ "regex",
+ "ryu",
+ "serde",
+ "serde_json",
+ "serde_repr",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+
+[[package]]
+name = "js-sys"
+version = "0.3.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54c0c35952f67de54bb584e9fd912b3023117cbafc0a77d8f3dee1fb5f572fe8"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"
+
+[[package]]
+name = "lock_api"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "memchr"
+version = "2.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
+
+[[package]]
+name = "memoffset"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "parse-zoneinfo"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "phf"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e681a6cfdc4adcc93b4d3cf993749a4552018ee0a9b65fc0ccfad74352c72a38"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "parking_lot",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "076c73d0bc438f7a4ef6fdd0c3bb4732149136abd952b110ac93e4edb13a6ba5"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53cee42e77ebe256066ba8aa77eff722b3bb91f3419177cf4cd0f304d3284d9"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfeb4c99597e136528c6dd7d5e3de5434d1ceaf487436a3f03b2d56b6fc9efd1"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "947dc12175c254889edc0c02e399476c2f652b4b9ebd123aa655c224de259536"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "pyroncalc"
+version = "0.1.0"
+dependencies = [
+ "ironcalc",
+ "pyo3",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
+[[package]]
+name = "roxmltree"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf7d7b1ea646d380d0e8153158063a6da7efe30ddbf3184042848e3f8a6f671"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.192"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bca2a08484b285dcb282d0f67b26cadc0df8b19f8c12502c13d966bf9482f001"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.192"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6c7207fbec9faa48073f3e3074cbe553af6ea512d7c21ba46e434e70ea9fbc1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3081f5ffbb02284dda55132aa26daecedd7372a42417bbbab6f14ab7d6bb9145"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "smallvec"
+version = "1.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c39fd04924ca3a864207c66fc2cd7d22d7c016007f9ce846cbb9326331930a"
+
+[[package]]
+name = "thiserror"
+version = "1.0.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unindent"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7daec296f25a1bae309c0cd5c29c4b260e510e6d813c286b19eaadf409d40fce"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e397f4664c0e4e428e8313a469aaa58310d302159845980fd23b0f22a847f217"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5961017b3b08ad5f3fe39f1e79877f8ee7c23c5e5fd5eb80de95abc41f1f16b2"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5353b8dab669f5e10f5bd76df26a9360c748f054f862ff5f3f8aae0c7fb3907"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d046c5d029ba91a1ed14da14dca44b68bf2f124cfbaf741c54151fdb3e0750b"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.51.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
+[[package]]
+name = "zip"
+version = "0.5.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93ab48844d61251bb3835145c521d88aa4031d7139e8485990f60ca911fa0815"
+dependencies = [
+ "byteorder",
+ "bzip2",
+ "crc32fast",
+ "flate2",
+ "thiserror",
+ "time",
+]

bindings/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyroncalc"
-version = "0.3.0"
+version = "0.1.2"
 edition = "2021"
 
 
@@ -12,8 +12,8 @@ crate-type = ["cdylib"]
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.3.0" }
+xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.2.0" }
-pyo3 = { version = "0.23", features = ["extension-module"] }
+pyo3 = { version = "0.22.3", features = ["extension-module"] }
 
 
 [features]

bindings/python/docs/api_reference.rst

@@ -1,210 +0,0 @@
-
-API Reference
--------------
-
-In general methods in IronCalc use a 0-index base for the the sheet index and 1-index base for the row and column indexes.
-
-
-.. method:: evaluate()
-
-   Evaluates the model. This needs to be done after each change, otherwise the model might be on a broken state.
-
-.. method:: set_user_input(sheet: int, row: int, column: int, value: str)
-
-      Sets an input in a cell, as would be done by a user typing into a spreadsheet cell.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index (first row is 1).
-      :param column: The 1-based column index (column “A” is 1).
-      :param value: The value to set, e.g. ``"123"`` or ``"=A1*2"``.
-
-.. method:: clear_cell_contents(sheet: int, row: int, column: int)
-
-      Removes the content of the cell but leaves the style intact.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index (first row is 1).
-      :param column: The 1-based column index (column “A” is 1).
-
-.. method:: get_cell_content(sheet: int, row: int, column: int) -> str
-
-      Returns the raw content of a cell. If the cell contains a formula, 
-      the returned string starts with ``"="``.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :param column: The 1-based column index.
-      :returns: The raw content, or an empty string if the cell is empty.
-
-.. method:: get_cell_type(sheet: int, row: int, column: int) -> PyCellType
-
-      Returns the type of the cell (number, boolean, string, error, etc.).
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :param column: The 1-based column index.
-      :rtype: PyCellType
-
-.. method:: get_formatted_cell_value(sheet: int, row: int, column: int) -> str
-
-      Returns the cell’s value as a formatted string, taking into 
-      account any number/currency/date formatting.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :param column: The 1-based column index.
-      :returns: Formatted string of the cell’s value.
-
-.. method:: set_cell_style(sheet: int, row: int, column: int, style: PyStyle)
-
-      Sets the style of the cell at (sheet, row, column).
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :param column: The 1-based column index.
-      :param style: A PyStyle object specifying the style.
-
-.. method:: get_cell_style(sheet: int, row: int, column: int) -> PyStyle
-
-      Retrieves the style of the specified cell.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :param column: The 1-based column index.
-      :returns: A PyStyle object describing the cell’s style.
-
-.. method:: insert_rows(sheet: int, row: int, row_count: int)
-
-      Inserts new rows.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The position before which new rows are inserted (1-based).
-      :param row_count: The number of rows to insert.
-
-.. method:: insert_columns(sheet: int, column: int, column_count: int)
-
-      Inserts new columns.
-
-      :param sheet: The sheet index (0-based).
-      :param column: The position before which new columns are inserted (1-based).
-      :param column_count: The number of columns to insert.
-
-.. method:: delete_rows(sheet: int, row: int, row_count: int)
-
-      Deletes a range of rows.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The starting row to delete (1-based).
-      :param row_count: How many rows to delete.
-
-.. method:: delete_columns(sheet: int, column: int, column_count: int)
-
-      Deletes a range of columns.
-
-      :param sheet: The sheet index (0-based).
-      :param column: The starting column to delete (1-based).
-      :param column_count: How many columns to delete.
-
-.. method:: get_column_width(sheet: int, column: int) -> float
-
-      Retrieves the width of a given column.
-
-      :param sheet: The sheet index (0-based).
-      :param column: The 1-based column index.
-      :rtype: float
-
-.. method:: get_row_height(sheet: int, row: int) -> float
-
-      Retrieves the height of a given row.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :rtype: float
-
-.. method:: set_column_width(sheet: int, column: int, width: float)
-
-      Sets the width of a given column.
-
-      :param sheet: The sheet index (0-based).
-      :param column: The 1-based column index.
-      :param width: The desired width (float).
-
-.. method:: set_row_height(sheet: int, row: int, height: float)
-
-      Sets the height of a given row.
-
-      :param sheet: The sheet index (0-based).
-      :param row: The 1-based row index.
-      :param height: The desired height (float).
-
-.. method:: get_frozen_columns_count(sheet: int) -> int
-
-      Returns the number of columns frozen (pinned) on the left side of the sheet.
-
-      :param sheet: The sheet index (0-based).
-      :rtype: int
-
-.. method:: get_frozen_rows_count(sheet: int) -> int
-
-      Returns the number of rows frozen (pinned) at the top of the sheet.
-
-      :param sheet: The sheet index (0-based).
-      :rtype: int
-
-.. method:: set_frozen_columns_count(sheet: int, column_count: int)
-
-      Sets how many columns are frozen (pinned) on the left.
-
-      :param sheet: The sheet index (0-based).
-      :param column_count: The number of frozen columns (0-based).
-
-.. method:: set_frozen_rows_count(sheet: int, row_count: int)
-
-      Sets how many rows are frozen (pinned) at the top.
-
-      :param sheet: The sheet index (0-based).
-      :param row_count: The number of frozen rows (0-based).
-
-.. method:: get_worksheets_properties() -> List[PySheetProperty]
-
-      Returns a list of :class:`PySheetProperty` describing each worksheet’s 
-      name, visibility state, ID, and tab color.
-
-      :rtype: list of PySheetProperty
-
-.. method:: set_sheet_color(sheet: int, color: str)
-
-      Sets the tab color of a sheet. Use an empty string to clear the color.
-
-      :param sheet: The sheet index (0-based).
-      :param color: A color in “#RRGGBB” format, or empty to remove color.
-
-.. method:: add_sheet(sheet_name: str)
-
-      Creates a new sheet with the specified name.
-
-      :param sheet_name: The name to give the new sheet.
-
-.. method:: new_sheet()
-
-      Creates a new sheet with an auto-generated name.
-
-.. method:: delete_sheet(sheet: int)
-
-      Deletes the sheet at the given index.
-
-      :param sheet: The sheet index (0-based).
-
-.. method:: rename_sheet(sheet: int, new_name: str)
-
-      Renames the sheet at the given index.
-
-      :param sheet: The sheet index (0-based).
-      :param new_name: The new sheet name.
-
-.. method:: test_panic()
-
-      A test method that deliberately panics in Rust. 
-      Used for testing panic handling at the method level.
-
-      :raises WorkbookError: (wrapped Rust panic)

bindings/python/docs/index.rst

@@ -1,20 +1,13 @@
-IronCalc
+IronCalc: The democratization of spreadsheets
-========
+=============================================
 
 .. toctree::
    :maxdepth: 2
    :caption: Contents:
 
-   installation
+IronCalc is a spreadsheet engine that allows you to create, modify and safe spreadsheets.
-   usage_examples
-   top_level_methods
-   api_reference
-   objects
-
-IronCalc is a spreadsheet engine that allows you to create, modify and save spreadsheets.
 
 A simple example that creates a model, sets a formula, evaluates it and gets the result back:
 
 .. literalinclude:: examples/simple.py
-   :language: python
+   :language: python
-

bindings/python/docs/installation.rst

@@ -1,9 +0,0 @@
-Installation
-------------
-
-You can simply do:
-
-.. code-block:: bash
-
-   pip install ironcalc
-