mobile: fix android widget bugs

.github/actions/setup-node-with-cache/action.yml

@@ -14,8 +14,6 @@ runs:
           apps/mobile/package-lock.json
           apps/desktop/package-lock.json
           apps/web/package-lock.json
-          apps/monograph/package-lock.json
-          apps/theme-builder/package-lock.json
           extensions/web-clipper/package-lock.json
           packages/core/package-lock.json
           packages/crypto/package-lock.json
@@ -26,4 +24,3 @@ runs:
           packages/logger/package-lock.json
           packages/streamable-fs/package-lock.json
           packages/theme/package-lock.json
-          packages/intl/package-lock.json

.github/workflows/core.tests.yml

@@ -18,7 +18,7 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/desktop.publish.yml

@@ -33,19 +33,11 @@ on:
         required: true
         default: true
         description: "Build for macOS?"
-      release-track:
-        type: choice
-        required: true
-        default: stable
-        description: "Select the release track"
-        options:
-          - stable
-          - beta
 
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -57,30 +49,14 @@ jobs:
         run: |
           npm ci --ignore-scripts --prefer-offline --no-audit
           npm run bootstrap -- --scope=web
-          npm run bootstrap -- --scope=desktop
-
-      - name: Install sqlite-better-trigram for all arch
-        run: |
-          npm i --cpu arm64 sqlite-better-trigram
-          npm i --cpu x64 sqlite-better-trigram
-        working-directory: ./apps/desktop
 
       - name: Setup environment
         run: |
           echo "NX_CLOUD_ACCESS_TOKEN=${{ secrets.NX_CLOUD_ACCESS_TOKEN }}" >> $GITHUB_ENV
 
-      - name: Generate desktop build (stable)
-        if: ${{ inputs.release-track == 'stable' }}
+      - name: Generate desktop build
         run: npx nx build:desktop @notesnook/web
 
-      - name: Generate desktop build (beta)
-        if: ${{ inputs.release-track == 'beta' }}
-        run: BETA=true npx nx build:desktop @notesnook/web
-
-      - name: Build desktop bundle
-        working-directory: ./apps/desktop
-        run: npm run bundle
-
       - name: Archive build artifact
         uses: actions/upload-artifact@v4
         with:
@@ -95,8 +71,7 @@ jobs:
 
       - name: Package desktop build
         run: |
-          cp -r ./apps/web/build ./apps/desktop/
-          zip -r ./notesnook_build_v${{ steps.app_metadata.outputs.app_version }}.zip ./apps/desktop/build/
+          zip -r ./notesnook_build_v${{ steps.app_metadata.outputs.app_version }}.zip ./apps/web/build/
           echo "Build folder archived to ./notesnook_build_v${{ steps.app_metadata.outputs.app_version }}.zip"
 
       - name: Upload desktop build
@@ -112,8 +87,7 @@ jobs:
       - name: Generate flatpak sources
         if: inputs.publish-github && inputs.build-linux
         run: |
-          sudo apt-get update
-          sudo apt-get install -y --quiet flatpak flatpak-builder pipx
+          sudo apt-get install -y flatpak flatpak-builder pipx
           git clone https://github.com/flatpak/flatpak-builder-tools.git /tmp/flatpak-builder-tools
           cd /tmp/flatpak-builder-tools/node
           pipx install .
@@ -199,7 +173,7 @@ jobs:
           CSC_KEY_PASSWORD: ${{ secrets.mac_certs_password }}
         run: |
           npx nx run release --project @notesnook/desktop -- --variant=mas
-          yarn electron-builder --config=electron-builder.config.js --mac mas --universal -p never
+          yarn electron-builder --mac mas --universal -p never
         working-directory: ./apps/desktop
 
       - name: Build zip and dmg
@@ -213,9 +187,9 @@ jobs:
         run: |
           npx nx run release --project @notesnook/desktop
           if [ ${{ inputs.publish-github }} == true ]; then
-            yarn electron-builder --config=electron-builder.config.js --mac zip dmg --arm64 --x64 -p always
+            yarn electron-builder --mac zip dmg --arm64 --x64 -p always
           else
-            yarn electron-builder --config=electron-builder.config.js --mac zip dmg --arm64 --x64 -p never
+            yarn electron-builder --mac zip dmg --arm64 --x64 -p never
           fi
         working-directory: ./apps/desktop
 
@@ -277,7 +251,7 @@ jobs:
       - name: Build snap
         if: inputs.publish-snap
         run: |
-          yarn electron-builder --config=electron-builder.config.js --linux snap:x64 -p never
+          yarn electron-builder --linux snap:x64 -p never
         working-directory: ./apps/desktop
 
       - name: Build AppImage
@@ -285,9 +259,9 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           if [ ${{ inputs.publish-github }} == true ]; then
-            yarn electron-builder --config=electron-builder.config.js --linux AppImage:x64 AppImage:arm64 -p always
+            yarn electron-builder --linux AppImage:x64 AppImage:arm64 -p always
           else
-            yarn electron-builder --config=electron-builder.config.js --linux AppImage:x64 AppImage:arm64 -p never
+            yarn electron-builder --linux AppImage:x64 AppImage:arm64 -p never
           fi
         working-directory: ./apps/desktop
 
@@ -347,8 +321,8 @@ jobs:
           AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
         run: |
           if ($${{ inputs.publish-github }} -eq $true) {
-            yarn electron-builder --config=electron-builder.config.js --win --publish always
+            yarn electron-builder --win --publish always
           } else {
-            yarn electron-builder --config=electron-builder.config.js --win --publish never
+            yarn electron-builder --win --publish never
           }
         working-directory: ./apps/desktop

.github/workflows/desktop.tests.yml

@@ -14,7 +14,7 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -69,11 +69,12 @@ jobs:
 
       - name: Build app
         run: |
-          yarn electron-builder --config=electron-builder.config.js --mac --dir --x64
+          yarn electron-builder --mac --dir --x64
         working-directory: ./apps/desktop
 
       - name: Run tests x64
-        run: npm run test
+        run: |
+          EXECUTABLE_PATH=output/mac/Notesnook.app/Contents/MacOS/Notesnook npm run test
         working-directory: ./apps/desktop
 
       - name: Upload test results
@@ -113,11 +114,12 @@ jobs:
 
       - name: Build app
         run: |
-          yarn electron-builder --config=electron-builder.config.js --mac --dir --arm64
+          yarn electron-builder --mac --dir --arm64
         working-directory: ./apps/desktop
 
       - name: Run tests arm64
-        run: npm run test
+        run: |
+          EXECUTABLE_PATH=output/mac-arm64/Notesnook.app/Contents/MacOS/Notesnook npm run test
         working-directory: ./apps/desktop
 
       - name: Upload test results
@@ -131,7 +133,7 @@ jobs:
   test-linux:
     name: Test for Linux
     needs: build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
 
     steps:
       - name: Check out Git repository
@@ -163,11 +165,12 @@ jobs:
 
       - name: Build app
         run: |
-          yarn electron-builder --config=electron-builder.config.js --linux --dir --arm64 --x64
+          yarn electron-builder --linux --dir --arm64 --x64
         working-directory: ./apps/desktop
 
       - name: Run tests
-        run: xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24" -- npm run test
+        run: |
+          EXECUTABLE_PATH=output/linux-unpacked/notesnook xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24" -- npm run test
         working-directory: ./apps/desktop
 
       - name: Upload test results
@@ -213,11 +216,12 @@ jobs:
 
       - name: Build app
         run: |
-          npx cross-env NOTESNOOK_STAGING=true yarn electron-builder --config=electron-builder.config.js --win --dir --arm64 --x64
+          npx cross-env NOTESNOOK_STAGING=true yarn electron-builder --win --dir --arm64 --x64
         working-directory: ./apps/desktop
 
       - name: Run tests
-        run: npm run test
+        run: |
+          npx cross-env EXECUTABLE_PATH=output/win-unpacked/Notesnook.exe npm run test
         working-directory: ./apps/desktop
 
       - name: Upload test results

.github/workflows/editor.tests.yml

@@ -19,7 +19,7 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/help.publish.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/ios.publish.yml

@@ -9,7 +9,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
 
       - name: Setup Node
         uses: ./.github/actions/setup-node-with-cache
@@ -47,7 +47,7 @@ jobs:
           ccache -p
 
       - name: Cache Pods
-        uses: actions/cache@v3
+        uses: actions/cache@v2
         id: pods-cache
         with:
           path: apps/mobile/native/ios/Pods

.github/workflows/monograph.publish.yml

@@ -14,7 +14,7 @@ on: workflow_dispatch
 jobs:
   push_to_registry:
     name: Push Docker image to Docker Hub
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     permissions:
       packages: write
       contents: read

.github/workflows/theme-builder.publish.yml

@@ -5,7 +5,7 @@ on: workflow_dispatch
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/vericrypt.publish.yml

@@ -5,7 +5,7 @@ on: workflow_dispatch
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/web.benchmarks.yml

@@ -14,7 +14,7 @@ on:
 jobs:
   bench:
     name: Bench
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/web.publish.yml

@@ -1,21 +1,11 @@
 name: Publish @notesnook/web
 
-on:
-  workflow_dispatch:
-    inputs:
-      release-track:
-        type: choice
-        required: true
-        default: stable
-        description: "Select the release track"
-        options:
-          - stable
-          - beta
+on: workflow_dispatch
 
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -34,20 +24,8 @@ jobs:
           echo "CLOUDFLARE_ACCOUNT_ID=${{ secrets.CLOUDFLARE_ACCOUNT_ID }}" >> $GITHUB_ENV
           echo "CLOUDFLARE_API_TOKEN=${{ secrets.CLOUDFLARE_API_TOKEN }}" >> $GITHUB_ENV
 
-      - name: Generate build (stable)
-        if: ${{ inputs.release-track == 'stable' }}
+      - name: Generate build
         run: npm run build:web
 
-      - name: Publish to Cloudflare Pages (stable)
-        if: ${{ inputs.release-track == 'stable' }}
-        working-directory: ./apps/web
-        run: npx --yes wrangler pages deploy --project-name=notesnook-app ./build/
-
-      - name: Generate build (beta)
-        if: ${{ inputs.release-track == 'beta' }}
-        run: npm run build:beta:web
-
-      - name: Publish to Cloudflare Pages (beta)
-        if: ${{ inputs.release-track == 'beta' }}
-        working-directory: ./apps/web
-        run: npx --yes wrangler pages deploy --branch=beta --project-name=notesnook-app-beta ./build/
+      - name: Publish to Cloudflare Pages
+        run: npx --yes wrangler pages deploy --project-name=notesnook-app ./apps/web/build/

.github/workflows/web.tests.yml

@@ -19,7 +19,7 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -49,7 +49,7 @@ jobs:
     name: 🧪 Test (${{ matrix.shard }}/${{ strategy.job-total }})
     strategy:
       matrix:
-        shard: [1, 2, 3, 4, 5]
+        shard: [1, 2, 3, 4]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout

.gitignore

@@ -11,4 +11,3 @@ nx-cloud.env
 site
 node_modules.backup
 .nx
-*.patch

apps/desktop/.gitignore

@@ -2,6 +2,4 @@ node_modules
 build
 output
 dist
-_catalog
-test-results
-test-artifacts
+_catalog

apps/desktop/README.md

@@ -58,13 +58,13 @@ This will compile and run the app in production mode but it won't generate any p
 npm run release -- --rebuild
 
 # For macOS
-npx electron-builder --config=electron-builder.config.js --mac dmg --arm64 --x64 -publish never
+npx electron-builder --mac dmg --arm64 --x64 -publish never
 
 # For Linux (AppImage)
-npx electron-builder --config=electron-builder.config.js --linux AppImage:x64 AppImage:arm64 -publish never
+npx electron-builder --linux AppImage:x64 AppImage:arm64 -publish never
 
 # For Windows
-npx electron-builder --config=electron-builder.config.js --win --publish never
+npx electron-builder --win --publish never
 ```
 
 Feel free to play around with the `electron-builder` command to get the packages you need. `npx electron-builder --help` is a great resource to learn different commands & platforms supported by `electron-builder`.

apps/desktop/__tests__/auto-updates.test.ts

@@ -1,246 +0,0 @@
-/*
-This file is part of the Notesnook project (https://notesnook.com/)
-
-Copyright (C) 2023 Streetwriters (Private) Limited
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-import { test } from "vitest";
-import { harness } from "./utils.js";
-import { writeFile } from "fs/promises";
-import { Page } from "playwright";
-import { gt, lt } from "semver";
-
-test("update starts downloading if version is outdated", async (t) => {
-  await harness(
-    t,
-    async ({ page }) => {
-      await page.waitForSelector("#authForm");
-
-      t.expect(
-        await page.getByRole("button", { name: "Create account" }).isVisible()
-      ).toBe(true);
-
-      await page
-        .getByRole("button", { name: "Skip & go directly to the app" })
-        .click();
-
-      await skipDialog(page);
-
-      await page.waitForSelector(".ProseMirror");
-
-      await page
-        .locator(".theme-scope-statusBar")
-        .getByRole("button", { name: /updating/i })
-        .waitFor({ state: "attached" });
-    },
-    { version: "3.0.0" }
-  );
-});
-
-test("update is only shown if version is outdated and auto updates are disabled", async (t) => {
-  await harness(
-    t,
-    async (ctx) => {
-      await ctx.app.close();
-      await writeFile(
-        ctx.configPath,
-        JSON.stringify({
-          automaticUpdates: false
-        })
-      );
-
-      await ctx.relaunch();
-
-      const { page } = ctx;
-
-      await page.waitForSelector("#authForm");
-
-      t.expect(
-        await page.getByRole("button", { name: "Create account" }).isVisible()
-      ).toBe(true);
-
-      await page
-        .getByRole("button", { name: "Skip & go directly to the app" })
-        .click();
-
-      await skipDialog(page);
-
-      await page.waitForSelector(".ProseMirror");
-
-      await page
-        .locator(".theme-scope-statusBar")
-        .getByRole("button", { name: /available/i })
-        .waitFor({ state: "attached" });
-    },
-    { version: "3.0.0" }
-  );
-});
-
-test("update to stable if it is newer", async (t) => {
-  await harness(
-    t,
-    async (ctx) => {
-      await ctx.app.close();
-      await writeFile(
-        ctx.configPath,
-        JSON.stringify({
-          automaticUpdates: false,
-          releaseTrack: "beta"
-        })
-      );
-
-      await ctx.relaunch();
-
-      const { page } = ctx;
-
-      await page.waitForSelector("#authForm");
-
-      t.expect(
-        await page.getByRole("button", { name: "Create account" }).isVisible()
-      ).toBe(true);
-
-      await page
-        .getByRole("button", { name: "Skip & go directly to the app" })
-        .click();
-
-      await skipDialog(page);
-
-      await page.waitForSelector(".ProseMirror");
-
-      const updateButton = page
-        .locator(".theme-scope-statusBar")
-        .getByRole("button", { name: /available/i });
-      await updateButton.waitFor({ state: "visible" });
-      const content = await updateButton.textContent();
-      const version = content?.split(" ")?.[0] || "";
-      t.expect(gt(version, "3.0.0-beta.0")).toBe(true);
-    },
-    { version: "3.0.0-beta.0" }
-  );
-});
-
-test("update is not available if it latest stable version is older", async (t) => {
-  await harness(
-    t,
-    async (ctx) => {
-      await ctx.app.close();
-      await writeFile(
-        ctx.configPath,
-        JSON.stringify({
-          automaticUpdates: false,
-          releaseTrack: "beta"
-        })
-      );
-
-      await ctx.relaunch();
-
-      const { page } = ctx;
-
-      await page.waitForSelector("#authForm");
-
-      t.expect(
-        await page.getByRole("button", { name: "Create account" }).isVisible()
-      ).toBe(true);
-
-      await page
-        .getByRole("button", { name: "Skip & go directly to the app" })
-        .click();
-
-      await skipDialog(page);
-
-      await page.waitForSelector(".ProseMirror");
-
-      await page
-        .locator(".theme-scope-statusBar")
-        .getByRole("button", { name: /checking for updates/i })
-        .waitFor({ state: "hidden" });
-
-      t.expect(
-        await page
-          .locator(".theme-scope-statusBar")
-          .getByRole("button", { name: /available/i })
-          .isHidden()
-      ).toBe(true);
-    },
-    { version: "99.0.0-beta.0" }
-  );
-});
-
-test("downgrade to stable on switching to stable release track", async (t) => {
-  await harness(
-    t,
-    async (ctx) => {
-      await ctx.app.close();
-      await writeFile(
-        ctx.configPath,
-        JSON.stringify({
-          automaticUpdates: false,
-          releaseTrack: "stable"
-        })
-      );
-
-      await ctx.relaunch();
-
-      const { page } = ctx;
-
-      await page.waitForSelector("#authForm");
-
-      t.expect(
-        await page.getByRole("button", { name: "Create account" }).isVisible()
-      ).toBe(true);
-
-      await page
-        .getByRole("button", { name: "Skip & go directly to the app" })
-        .click();
-
-      await skipDialog(page);
-
-      await page.waitForSelector(".ProseMirror");
-
-      await page
-        .locator(".theme-scope-statusBar")
-        .getByRole("button", { name: /checking for updates/i })
-        .waitFor({ state: "hidden" });
-
-      const updateButton = page
-        .locator(".theme-scope-statusBar")
-        .getByRole("button", { name: /available/i });
-      await updateButton.waitFor({ state: "visible" });
-      const content = await updateButton.textContent();
-      const version = content?.split(" ")?.[0] || "";
-      t.expect(lt(version, "99.0.0-beta.0")).toBe(true);
-    },
-    { version: "99.0.0-beta.0" }
-  );
-});
-
-async function skipDialog(page: Page) {
-  await page
-    .waitForSelector(".ReactModal__Content", {
-      timeout: 1000
-    })
-    .catch(() => {})
-    .then(async () => {
-      const positiveButton = page.locator(
-        "button[data-role='positive-button']"
-      );
-      const negativeButton = page.locator(
-        "button[data-role='negative-button']"
-      );
-      if (await positiveButton.isVisible()) await positiveButton.click();
-      else if (await negativeButton.isVisible()) await negativeButton.click();
-    });
-}

apps/desktop/__tests__/launch.test.mjs

@@ -17,12 +17,16 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { test } from "vitest";
-import { harness } from "./utils.js";
+import test from "node:test";
+import { launchApp } from "./utils.mjs";
 import assert from "assert";
+import slugify from "slugify";
+import path from "path";
+import { mkdir } from "fs/promises";
 
 test("make sure app loads", async (t) => {
-  await harness(t, async ({ page }) => {
+  const { app, page } = await launchApp();
+  try {
     await page.waitForSelector("#authForm");
 
     assert.ok(
@@ -34,5 +38,16 @@ test("make sure app loads", async (t) => {
       .click();
 
     await page.waitForSelector(".ProseMirror");
-  });
+  } catch (e) {
+    await mkdir("test-results", { recursive: true });
+    await page.screenshot({
+      path: path.join(
+        "test-results",
+        `${slugify(t.name)}-${process.platform}-${process.arch}-error.png`
+      )
+    });
+    throw e;
+  } finally {
+    await app.close();
+  }
 });

apps/desktop/__tests__/utils.mjs

@@ -17,7 +17,22 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-export function exitFullscreen() {
-  if (!document.fullscreenElement) return;
-  document.exitFullscreen();
+import { _electron as electron } from "playwright";
+
+const executablePath = process.env.EXECUTABLE_PATH;
+
+// process.platform === "linux"
+//   ? "output/linux-unpacked/Notesnook"
+//   : process.platform === "darwin"
+//   ? "output/mac/Notesnook.app/Contents/MacOS/Notesnook"
+//   : "output/win-unpacked/Notesnook.exe";
+
+export async function launchApp() {
+  const app = await electron.launch({
+    executablePath
+  });
+
+  const page = await app.firstWindow();
+
+  return { app, page };
 }

apps/desktop/__tests__/utils.ts

@@ -1,172 +0,0 @@
-/*
-This file is part of the Notesnook project (https://notesnook.com/)
-
-Copyright (C) 2023 Streetwriters (Private) Limited
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-import { execSync } from "child_process";
-import { mkdir } from "fs/promises";
-import { fileURLToPath } from "node:url";
-import path from "path";
-import { _electron as electron } from "playwright";
-import slugify from "slugify";
-import { TaskContext } from "vitest";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const IS_DEBUG = process.env.NN_DEBUG === "true" || process.env.CI === "true";
-
-interface AppContext {
-  app: import("playwright").ElectronApplication;
-  page: import("playwright").Page;
-  configPath: string;
-  relaunch: () => Promise<void>;
-}
-
-interface TestOptions {
-  version: string;
-}
-
-export async function harness(
-  t: TaskContext,
-  cb: (ctx: AppContext) => Promise<void>,
-  options?: TestOptions
-) {
-  const ctx = await buildAndLaunchApp(options);
-
-  t.onTestFinished(async (result) => {
-    if (result.state === "fail") {
-      await mkdir("test-results", { recursive: true });
-      await ctx.page.screenshot({
-        path: path.join(
-          "test-results",
-          `${slugify(t.task.name)}-${process.platform}-${
-            process.arch
-          }-error.png`
-        )
-      });
-    }
-    await ctx.app.close();
-  });
-
-  await cb(ctx);
-}
-
-async function buildAndLaunchApp(options?: TestOptions): Promise<AppContext> {
-  const productName = makeid(10);
-  const executablePath = await buildApp({ ...options, productName });
-  const { app, page, configPath } = await launchApp(executablePath);
-  const ctx: AppContext = {
-    app,
-    page,
-    configPath,
-    relaunch: async () => {
-      const { app, page, configPath } = await launchApp(executablePath);
-      ctx.app = app;
-      ctx.page = page;
-      ctx.configPath = configPath;
-    }
-  };
-  return ctx;
-}
-
-async function launchApp(executablePath: string) {
-  const app = await electron.launch({
-    executablePath,
-    args: IS_DEBUG ? [] : ["--hidden"],
-    env:
-      process.platform === "linux"
-        ? {
-            ...(process.env as Record<string, string>),
-            APPIMAGE: "true"
-          }
-        : (process.env as Record<string, string>)
-  });
-
-  const page = await app.firstWindow();
-
-  const userDataDirectory = await app.evaluate((a) => {
-    return a.app.getPath("userData");
-  });
-  const configPath = path.join(userDataDirectory, "config.json");
-  return {
-    app,
-    page,
-    configPath
-  };
-}
-
-async function buildApp({
-  version,
-  productName
-}: {
-  version?: string;
-  productName: string;
-}) {
-  const buildRoot = path.join("test-artifacts", `${productName}-build`);
-  const output = path.join("test-artifacts", `${productName}-output`);
-  execSync(`npm run release -- --root ${buildRoot} --skip-tsc-build`, {
-    stdio: IS_DEBUG ? "inherit" : "ignore"
-  });
-
-  const args = [
-    `--config electron-builder.config.js`,
-    `--c.extraMetadata.productName=${productName}`,
-    "--publish=never"
-  ];
-  if (version) args.push(`--c.extraMetadata.version=${version}`);
-
-  execSync(`npx electron-builder --dir --${process.arch} ${args.join(" ")}`, {
-    stdio: IS_DEBUG ? "inherit" : "ignore",
-    env: {
-      ...process.env,
-      NOTESNOOK_STAGING: "true",
-      NN_BUILD_ROOT: buildRoot,
-      NN_PRODUCT_NAME: productName,
-      NN_APP_ID: `com.notesnook.test.${productName}`,
-      NN_OUTPUT_DIR: output
-    }
-  });
-
-  return path.join(
-    __dirname,
-    "..",
-    output,
-    process.platform === "linux"
-      ? process.arch === "arm64"
-        ? "linux-arm64-unpacked"
-        : "linux-unpacked"
-      : process.platform === "darwin"
-      ? process.arch === "arm64"
-        ? `mac-arm64/${productName}.app/Contents/MacOS/`
-        : `mac/${productName}.app/Contents/MacOS/`
-      : "win-unpacked",
-    process.platform === "win32" ? `${productName}.exe` : productName
-  );
-}
-
-function makeid(length: number) {
-  let result = "";
-  const characters =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const charactersLength = characters.length;
-  let counter = 0;
-  while (counter < length) {
-    result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    counter += 1;
-  }
-  return result.toLowerCase();
-}

apps/desktop/electron-builder.config.js

@@ -1,200 +0,0 @@
-/*
-This file is part of the Notesnook project (https://notesnook.com/)
-
-Copyright (C) 2023 Streetwriters (Private) Limited
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-const path = require("path");
-
-const buildRoot = process.env.NN_BUILD_ROOT || ".";
-const buildFiles = [
-  `${buildRoot}/build/`,
-  `!${buildRoot}/build/screenshots\${/*}`,
-  `!${buildRoot}/build/banner.jpg`,
-  `!${buildRoot}/build/*.ico`,
-  `!${buildRoot}/build/*.png`
-];
-
-const productName = process.env.NN_PRODUCT_NAME || "Notesnook";
-const appId = process.env.NN_APP_ID || "org.streetwriters.notesnook";
-const outputDir = process.env.NN_OUTPUT_DIR || "output";
-const linuxExecutableName = process.env.NN_PRODUCT_NAME
-  ? process.env.NN_PRODUCT_NAME.toLowerCase().replace(/\s+/g, "-")
-  : "notesnook";
-const year = new Date().getFullYear();
-
-module.exports = {
-  appId: appId,
-  productName: productName,
-  copyright: `Copyright © ${year} Streetwriters (Private) Limited`,
-  artifactName: "notesnook_${os}_${arch}.${ext}",
-  generateUpdatesFilesForAllChannels: true,
-  asar: false,
-  files: [
-    "!*.chunk.js.map",
-    "!*.chunk.js.LICENSE.txt",
-    ...buildFiles,
-    "!node_modules${/*}",
-    "node_modules/better-sqlite3-multiple-ciphers/build/Release/better_sqlite3.node",
-    "node_modules/better-sqlite3-multiple-ciphers/lib",
-    "node_modules/better-sqlite3-multiple-ciphers/package.json",
-    "node_modules/file-uri-to-path",
-    "node_modules/bindings",
-    "node_modules/node-gyp-build",
-    "node_modules/sqlite-better-trigram",
-    "node_modules/sodium-native/prebuilds/${platform}-${arch}",
-    {
-      from: "node_modules/sqlite-better-trigram-linux-${arch}",
-      to: "node_modules/sqlite-better-trigram-linux-${arch}"
-    },
-    {
-      from: "node_modules/sqlite-better-trigram-darwin-${arch}",
-      to: "node_modules/sqlite-better-trigram-darwin-${arch}"
-    },
-    {
-      from: "node_modules/sqlite-better-trigram-windows-${arch}",
-      to: "node_modules/sqlite-better-trigram-windows-${arch}"
-    },
-    "node_modules/sodium-native/index.js",
-    "node_modules/sodium-native/package.json"
-  ],
-  afterPack: "./scripts/removeLocales.js",
-  mac: {
-    bundleVersion: "240",
-    minimumSystemVersion: "10.12.0",
-    target: [
-      {
-        target: "dmg",
-        arch: ["arm64", "x64"]
-      },
-      {
-        target: "zip",
-        arch: ["arm64", "x64"]
-      }
-    ],
-    category: "public.app-category.productivity",
-    darkModeSupport: true,
-    type: "distribution",
-    hardenedRuntime: true,
-    entitlements: "assets/entitlements.mac.plist",
-    entitlementsInherit: "assets/entitlements.mac.plist",
-    gatekeeperAssess: false,
-    icon: "assets/icons/app.icns",
-    notarize: true
-  },
-  dmg: {
-    contents: [
-      {
-        x: 130,
-        y: 220
-      },
-      {
-        x: 410,
-        y: 220,
-        type: "link",
-        path: "/Applications"
-      }
-    ],
-    icon: "assets/icons/app.icns",
-    title: "Install Notesnook"
-  },
-  mas: {
-    entitlements: "assets/entitlements.mas.plist",
-    entitlementsInherit: "assets/entitlements.mas.inherit.plist",
-    entitlementsLoginHelper: "assets/entitlements.mas.loginhelper.plist",
-    hardenedRuntime: true
-  },
-  win: {
-    target: [
-      {
-        target: "nsis",
-        arch: ["x64", "arm64"]
-      },
-      {
-        target: "portable",
-        arch: ["x64", "arm64"]
-      }
-    ],
-    signtoolOptions: {
-      signingHashAlgorithms: ["sha256"],
-      sign: "./scripts/sign.js"
-    },
-    icon: "assets/icons/app.ico"
-  },
-  portable: {
-    artifactName: "notesnook_${os}_${arch}_portable.${ext}"
-  },
-  nsis: {
-    oneClick: true,
-    createDesktopShortcut: "always",
-    deleteAppDataOnUninstall: true
-  },
-  linux: {
-    target: [
-      {
-        target: "AppImage",
-        arch: ["x64", "arm64"]
-      },
-      {
-        target: "snap",
-        arch: ["x64", "arm64"]
-      }
-    ],
-    category: "Office",
-    icon: "assets/icons/app.icns",
-    description: "Your private note taking space",
-    executableName: linuxExecutableName,
-    desktop: {
-      actions: [
-        {
-          id: "new-note",
-          name: "New note",
-          args: "new note"
-        },
-        {
-          id: "new-notebook",
-          name: "New notebook",
-          args: "new notebook"
-        },
-        {
-          id: "new-reminder",
-          name: "New reminder",
-          args: "new reminder"
-        }
-      ]
-    }
-  },
-  snap: {
-    autoStart: false,
-    confinement: "strict",
-    allowNativeWayland: true
-  },
-  extraResources: ["app-update.yml", "./assets/**"],
-  extraMetadata: {
-    main: path.join(buildRoot, "build", "electron.js")
-  },
-  directories: {
-    buildResources: "assets",
-    output: outputDir
-  },
-  publish: [
-    {
-      provider: "github",
-      repo: "notesnook",
-      owner: "streetwriters"
-    }
-  ]
-};

apps/desktop/package.json

@@ -2,7 +2,7 @@
   "name": "@notesnook/desktop",
   "productName": "Notesnook",
   "description": "Your private note taking space",
-  "version": "3.0.31",
+  "version": "3.0.24",
   "appAppleId": "1544027013",
   "private": true,
   "main": "./dist/cjs/index.js",
@@ -25,12 +25,12 @@
   "repository": "https://github.com/streetwriters/notesnook",
   "license": "GPL-3.0-or-later",
   "dependencies": {
-    "@lingui/core": "5.1.2",
+    "@lingui/core": "4.11.4",
     "@notesnook/intl": "file:../../packages/intl",
     "@trpc/client": "10.45.2",
     "@trpc/server": "10.45.2",
     "better-sqlite3-multiple-ciphers": "11.5.0",
-    "electron-trpc": "0.7.1",
+    "electron-trpc": "0.6.1",
     "electron-updater": "^6.3.4",
     "icojs": "^0.19.4",
     "sqlite-better-trigram": "0.0.2",
@@ -46,14 +46,14 @@
     "electron": "^31.7.4",
     "electron-builder": "^25.1.8",
     "esbuild": "0.21.5",
+    "vitest": "2.1.8",
     "node-abi": "^3.68.0",
     "node-gyp-build": "^4.8.2",
     "playwright": "^1.48.2",
     "prebuildify": "^6.0.1",
     "slugify": "1.6.6",
     "tree-kill": "^1.2.2",
-    "undici": "^6.19.8",
-    "vitest": "^2.1.8"
+    "undici": "^6.19.8"
   },
   "optionalDependencies": {
     "dmg-license": "^1.0.11"
@@ -63,14 +63,203 @@
     "staging": "node scripts/build.mjs --run",
     "release": "node scripts/build.mjs",
     "build": "node ../../scripts/build.mjs",
-    "bundle": "esbuild electron=./src/main.ts ./src/preload.ts --external:electron --external:fsevents --external:better-sqlite3-multiple-ciphers --external:sodium-native --bundle --outdir=./build --platform=node --tsconfig=tsconfig.json --define:MAC_APP_STORE=false --define:RELEASE=true",
+    "bundle": "esbuild electron=./src/main.ts ./src/preload.ts --external:electron --external:fsevents --external:better-sqlite3-multiple-ciphers --external:sodium-native --minify --bundle --outdir=./build --platform=node --tsconfig=tsconfig.json --define:MAC_APP_STORE=false --define:RELEASE=true",
     "bundle:mas": "esbuild electron=./src/main.ts ./src/preload.ts --minify --external:electron --external:fsevents --bundle --outdir=./build --platform=node --tsconfig=tsconfig.json --define:MAC_APP_STORE=true --define:RELEASE=true",
     "postinstall": "patch-package",
-    "test": "vitest run"
+    "test": "node --test --test-timeout 30000 --test-force-exit"
   },
   "author": {
     "name": "Streetwriters (Private) Limited",
     "email": "support@streetwriters.co",
     "url": "https://streetwriters.co"
+  },
+  "build": {
+    "appId": "org.streetwriters.notesnook",
+    "productName": "Notesnook",
+    "copyright": "Copyright © 2023 Streetwriters (Private) Limited",
+    "artifactName": "notesnook_${os}_${arch}.${ext}",
+    "generateUpdatesFilesForAllChannels": true,
+    "asar": false,
+    "files": [
+      "!*.chunk.js.map",
+      "!*.chunk.js.LICENSE.txt",
+      "build/",
+      "!build/screenshots${/*}",
+      "!build/banner.jpg",
+      "!build/*.ico",
+      "!build/*.png",
+      "!node_modules${/*}",
+      "node_modules/better-sqlite3-multiple-ciphers/build/Release/better_sqlite3.node",
+      "node_modules/better-sqlite3-multiple-ciphers/lib",
+      "node_modules/better-sqlite3-multiple-ciphers/package.json",
+      "node_modules/file-uri-to-path",
+      "node_modules/bindings",
+      "node_modules/node-gyp-build",
+      "node_modules/sqlite-better-trigram",
+      "node_modules/sodium-native/prebuilds/${platform}-${arch}",
+      {
+        "from": "node_modules/sqlite-better-trigram-linux-${arch}",
+        "to": "node_modules/sqlite-better-trigram-linux-${arch}"
+      },
+      {
+        "from": "node_modules/sqlite-better-trigram-darwin-${arch}",
+        "to": "node_modules/sqlite-better-trigram-darwin-${arch}"
+      },
+      {
+        "from": "node_modules/sqlite-better-trigram-windows-${arch}",
+        "to": "node_modules/sqlite-better-trigram-windows-${arch}"
+      },
+      "node_modules/sodium-native/index.js",
+      "node_modules/sodium-native/package.json"
+    ],
+    "afterPack": "./scripts/removeLocales.js",
+    "mac": {
+      "bundleVersion": "240",
+      "minimumSystemVersion": "10.12.0",
+      "target": [
+        {
+          "target": "dmg",
+          "arch": [
+            "arm64",
+            "x64"
+          ]
+        },
+        {
+          "target": "zip",
+          "arch": [
+            "arm64",
+            "x64"
+          ]
+        }
+      ],
+      "category": "public.app-category.productivity",
+      "darkModeSupport": true,
+      "type": "distribution",
+      "hardenedRuntime": true,
+      "entitlements": "assets/entitlements.mac.plist",
+      "entitlementsInherit": "assets/entitlements.mac.plist",
+      "gatekeeperAssess": false,
+      "icon": "assets/icons/app.icns",
+      "notarize": true
+    },
+    "dmg": {
+      "contents": [
+        {
+          "x": 130,
+          "y": 220
+        },
+        {
+          "x": 410,
+          "y": 220,
+          "type": "link",
+          "path": "/Applications"
+        }
+      ],
+      "icon": "assets/icons/app.icns",
+      "title": "Install Notesnook"
+    },
+    "mas": {
+      "entitlements": "assets/entitlements.mas.plist",
+      "entitlementsInherit": "assets/entitlements.mas.inherit.plist",
+      "entitlementsLoginHelper": "assets/entitlements.mas.loginhelper.plist",
+      "hardenedRuntime": true
+    },
+    "win": {
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "portable",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "signtoolOptions": {
+        "signingHashAlgorithms": [
+          "sha256"
+        ],
+        "sign": "./scripts/sign.js"
+      },
+      "icon": "assets/icons/app.ico"
+    },
+    "portable": {
+      "artifactName": "notesnook_${os}_${arch}_portable.${ext}"
+    },
+    "nsis": {
+      "oneClick": true,
+      "createDesktopShortcut": "always",
+      "deleteAppDataOnUninstall": true
+    },
+    "linux": {
+      "target": [
+        {
+          "target": "AppImage",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "snap",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "category": "Office",
+      "icon": "assets/icons/app.icns",
+      "description": "Your private note taking space",
+      "executableName": "notesnook",
+      "desktop": {
+        "actions": [
+          {
+            "id": "new-note",
+            "name": "New note",
+            "args": "new note"
+          },
+          {
+            "id": "new-notebook",
+            "name": "New notebook",
+            "args": "new notebook"
+          },
+          {
+            "id": "new-reminder",
+            "name": "New reminder",
+            "args": "new reminder"
+          }
+        ]
+      }
+    },
+    "snap": {
+      "autoStart": false,
+      "confinement": "strict",
+      "allowNativeWayland": true
+    },
+    "extraResources": [
+      "app-update.yml",
+      "./assets/**"
+    ],
+    "extraMetadata": {
+      "main": "./build/electron.js"
+    },
+    "directories": {
+      "buildResources": "assets",
+      "output": "./output/"
+    },
+    "publish": [
+      {
+        "provider": "github",
+        "repo": "notesnook",
+        "owner": "streetwriters"
+      }
+    ]
   }
-}
+}

apps/desktop/scripts/build.mjs

@@ -29,12 +29,10 @@ import { patchBetterSQLite3 } from "./patch-better-sqlite3.mjs";
 const args = yargs(process.argv);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const root = args.root || path.join(__dirname, "..");
-const skipTscBuild = args.skipTscBuild || false;
 
 const webAppPath = path.resolve(path.join(__dirname, "..", "..", "web"));
 
-await fs.rm(path.join(root, "build"), { force: true, recursive: true });
+await fs.rm("./build/", { force: true, recursive: true });
 
 if (args.rebuild || !existsSync(path.join(webAppPath, "build"))) {
   await exec(
@@ -46,25 +44,21 @@ if (args.rebuild || !existsSync(path.join(webAppPath, "build"))) {
 // temporary until there's support for prebuilt binaries for linux ARM
 if (os.platform() === "linux") await patchBetterSQLite3();
 
-await fs.cp(path.join(webAppPath, "build"), path.join(root, "build"), {
+await fs.cp(path.join(webAppPath, "build"), "build", {
   recursive: true,
   force: true
 });
 
 if (args.variant === "mas") {
-  await exec(`yarn run bundle:mas --outdir=${path.join(root, "build")}`);
+  await exec(`yarn run bundle:mas`);
 } else {
-  await exec(`yarn run bundle --outdir=${path.join(root, "build")}`);
+  await exec(`yarn run bundle`);
 }
 
-if (!skipTscBuild) {
-  await exec(`yarn run build`);
-}
+await exec(`yarn run build`);
 
 if (args.run) {
-  await exec(
-    `yarn electron-builder --dir --${process.arch} --config=electron-builder.config.js`
-  );
+  await exec(`yarn electron-builder --dir --${process.arch}`);
   if (process.platform === "win32") {
     await exec(`.\\output\\win-unpacked\\Notesnook.exe`);
   } else if (process.platform === "darwin") {

apps/desktop/src/api/os-integration.ts

@@ -29,7 +29,7 @@ import { dirname } from "path";
 import { resolvePath } from "../utils/resolve-path";
 import { observable } from "@trpc/server/observable";
 import { AssetManager } from "../utils/asset-manager";
-import { isFlatpak, isSnap } from "../utils";
+import { isFlatpak } from "../utils";
 import { setupDesktopIntegration } from "../utils/desktop-integration";
 import { rm } from "fs/promises";
 import { disableCustomDns, enableCustomDns } from "../utils/custom-dns";
@@ -49,7 +49,6 @@ const NotificationOptions = z.object({
 
 export const osIntegrationRouter = t.router({
   isFlatpak: t.procedure.query(() => isFlatpak()),
-  isSnap: t.procedure.query(() => isSnap()),
 
   zoomFactor: t.procedure.query(() => config.zoomFactor),
   setZoomFactor: t.procedure.input(z.number()).mutation(({ input: factor }) => {

apps/desktop/src/api/updater.ts

@@ -23,7 +23,6 @@ import { CancellationToken, autoUpdater } from "electron-updater";
 import type { AppUpdaterEvents } from "electron-updater/out/AppUpdater";
 import { z } from "zod";
 import { config } from "../utils/config";
-import { app } from "electron";
 
 type UpdateInfo = { version: string };
 type Progress = { percent: number };
@@ -34,7 +33,6 @@ let downloadTimeout: NodeJS.Timeout | undefined = undefined;
 
 export const updaterRouter = t.router({
   autoUpdates: t.procedure.query(() => config.automaticUpdates),
-  releaseTrack: t.procedure.query(() => config.releaseTrack),
   install: t.procedure.query(() => autoUpdater.quitAndInstall()),
   download: t.procedure.query(async () => {
     if (cancellationToken) return;
@@ -69,13 +67,7 @@ export const updaterRouter = t.router({
     .mutation(({ input: { enabled } }) => {
       config.automaticUpdates = enabled;
     }),
-  changeReleaseTrack: t.procedure
-    .input(z.object({ track: z.string() }))
-    .mutation(({ input: { track } }) => {
-      config.releaseTrack = track;
-      app.relaunch();
-      app.exit();
-    }),
+
   onChecking: createSubscription("checking-for-update"),
   onDownloaded: createSubscription<"update-downloaded", UpdateInfo>(
     "update-downloaded"

apps/desktop/src/main.ts

@@ -85,8 +85,6 @@ async function createWindow() {
   const mainWindowState = new WindowState({});
   const mainWindow = new BrowserWindow({
     show: !cliOptions.hidden,
-    paintWhenInitiallyHidden: cliOptions.hidden,
-    skipTaskbar: cliOptions.hidden,
     x: mainWindowState.x,
     y: mainWindowState.y,
     width: mainWindowState.width,
@@ -103,10 +101,7 @@ async function createWindow() {
     ...(config.desktopSettings.nativeTitlebar
       ? {}
       : {
-          titleBarStyle:
-            process.platform === "win32" || process.platform === "darwin"
-              ? "hidden"
-              : "default",
+          titleBarStyle: process.platform === "win32" || process.platform === "darwin" ? "hidden" : "default",
           frame: process.platform === "win32" || process.platform === "darwin",
           titleBarOverlay: {
             height: 37,

apps/desktop/src/utils/autoupdater.ts

@@ -20,22 +20,19 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { autoUpdater } from "electron-updater";
 import { config } from "./config";
 
+const CHANNEL = autoUpdater.currentVersion.raw.endsWith("-beta")
+  ? "beta"
+  : "latest";
 async function configureAutoUpdater() {
-  const releaseTrack =
-    config.releaseTrack === "stable" ? "latest" : config.releaseTrack;
   autoUpdater.setFeedURL({
     provider: "generic",
-    url: `https://notesnook.com/api/v1/releases/${process.platform}/${releaseTrack}`,
+    url: `https://notesnook.com/api/v1/releases/${process.platform}/${CHANNEL}`,
     useMultipleRangeRequest: false,
-    channel: releaseTrack
+    channel: CHANNEL
   });
 
   autoUpdater.autoDownload = config.automaticUpdates;
-  autoUpdater.allowDowngrade =
-    // only allow downgrade if the current version is a prerelease
-    // and the user has changed the release track to stable
-    config.releaseTrack === "stable" &&
-    autoUpdater.currentVersion.prerelease.length > 0;
+  autoUpdater.allowDowngrade = false;
   autoUpdater.allowPrerelease = false;
   autoUpdater.autoInstallOnAppQuit = true;
   autoUpdater.disableWebInstaller = true;

apps/desktop/src/utils/config.ts

@@ -20,7 +20,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { nativeTheme } from "electron";
 import { JSONStorage } from "./json-storage";
 import { z } from "zod";
-import { autoUpdater } from "electron-updater";
 
 export const DesktopIntegration = z.object({
   autoStart: z.boolean().optional(),
@@ -47,9 +46,6 @@ export const config = {
   automaticUpdates: true,
   proxyRules: "",
   customDns: true,
-  releaseTrack: autoUpdater.currentVersion.raw.includes("-beta")
-    ? "beta"
-    : "stable",
 
   backgroundColor: nativeTheme.themeSource === "dark" ? "#0f0f0f" : "#ffffff",
   windowControlsIconColor:

apps/desktop/src/utils/index.ts

@@ -29,7 +29,3 @@ export function isDevelopment() {
 export function isFlatpak() {
   return existsSync("/.flatpak-info");
 }
-
-export function isSnap() {
-  return process.env.SNAP !== undefined;
-}

apps/desktop/vitest.config.ts

@@ -1,40 +0,0 @@
-/*
-This file is part of the Notesnook project (https://notesnook.com/)
-
-Copyright (C) 2023 Streetwriters (Private) Limited
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    testTimeout: process.env.CI ? 120 * 1000 : 120 * 1000,
-    sequence: {
-      concurrent: true,
-      shuffle: true
-    },
-    dir: "./__tests__/",
-    exclude: [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/cypress/**",
-      "**/.{idea,git,cache,output,temp}/**",
-      "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
-      "**/test-results/**",
-      "**/test-artifacts/**"
-    ]
-  }
-});

apps/mobile/app/app.tsx

@@ -39,6 +39,7 @@ import SettingsService from "./services/settings";
 import { TipManager } from "./services/tip-manager";
 import { useThemeStore } from "./stores/use-theme-store";
 import { useUserStore } from "./stores/use-user-store";
+import { IntentService } from "./services/intent";
 
 I18nManager.allowRTL(false);
 I18nManager.forceRTL(false);
@@ -48,6 +49,7 @@ if (appLockEnabled || appLockMode !== "none") {
   useUserStore.getState().lockApp(true);
 }
 
+IntentService.onLaunch();
 const App = (props: { configureMode: "note-preview" }) => {
   useAppEvents();
   //@ts-ignore

apps/mobile/app/common/filesystem/io.ts

@@ -231,26 +231,6 @@ export async function deleteDCacheFiles() {
   }
 }
 
-export async function getCachePathForFile(filename: string) {
-  const path = `${cacheDir}/${filename}`;
-
-  const iosAppGroup =
-    Platform.OS === "ios"
-      ? await (RNFetchBlob.fs as any).pathForAppGroup(IOS_APPGROUPID)
-      : null;
-  const appGroupPath = `${iosAppGroup}/${filename}`;
-
-  const exists = await RNFetchBlob.fs.exists(path);
-
-  // Check if file is present in app group path.
-  let existsInAppGroup = false;
-  if (!exists && Platform.OS === "ios") {
-    existsInAppGroup = await RNFetchBlob.fs.exists(appGroupPath);
-  }
-
-  return existsInAppGroup ? appGroupPath : path;
-}
-
 export async function exists(filename: string) {
   const path = `${cacheDir}/${filename}`;
 

apps/mobile/app/common/filesystem/utils.ts

@@ -115,7 +115,7 @@ export const FileSizeResult = {
   Error: -1
 };
 
-export async function getUploadedFileSize(hash: string, retry = 0) {
+export async function getUploadedFileSize(hash: string) {
   try {
     const url = `${hosts.API_HOST}/s3?name=${hash}`;
     const token = await db.tokenManager.getAccessToken();
@@ -123,24 +123,8 @@ export async function getUploadedFileSize(hash: string, retry = 0) {
       method: "HEAD",
       headers: { Authorization: `Bearer ${token}` }
     });
-
-    if (
-      !attachmentInfo.ok ||
-      attachmentInfo.headers?.get("content-length") === null
-    ) {
-      if (retry < 3) {
-        DatabaseLogger.log(`Retrying file size check: ${hash}, ${retry}`);
-        return getUploadedFileSize(hash, retry + 1);
-      }
-      throw new Error(
-        `File size check failed: ${hash}, ${
-          attachmentInfo.status
-        }, ${attachmentInfo.headers?.get("content-length")}`
-      );
-    }
-
     const contentLength = parseInt(
-      attachmentInfo.headers?.get("content-length") as string
+      attachmentInfo.headers?.get("content-length") || "0"
     );
     return isNaN(contentLength) ? FileSizeResult.Empty : contentLength;
   } catch (e) {

apps/mobile/app/components/app-lock-overlay/index.tsx

@@ -112,19 +112,14 @@ const AppLockedOverlay = () => {
     if (
       !biometricsAuthEnabled ||
       !(await BiometricService.isBiometryAvailable())
-    ) {
+    )
       return;
-    }
 
     biometricUnlockAwaitingUserInput.current = true;
 
     if (Platform.OS === "android") {
       const activityName = await NotesnookModule.getActivityName();
-      if (
-        activityName !== "MainActivity" &&
-        activityName !== "NotePreviewConfigureActivity"
-      )
-        return;
+      if (activityName !== "MainActivity") return;
     }
     useSettingStore.getState().setRequestBiometrics(true);
 
@@ -185,6 +180,7 @@ const AppLockedOverlay = () => {
         DatabaseLogger.info("Locking app on entering foreground");
         useUserStore.getState().lockApp(true);
       }
+
       if (
         !(
           biometricUnlockAwaitingUserInput.current ||

apps/mobile/app/components/attachments/actions.tsx

@@ -182,17 +182,18 @@ const Actions = ({
         relations
           .map((relation) => relation.fromId)
           .forEach(async (id) => {
-            useTabStore.getState().forEachNoteTab(id, async (tab) => {
-              const isFocused = useTabStore.getState().currentTab === tab.id;
+            const tab = useTabStore.getState().getTabForNote(id);
+            if (tab !== undefined) {
+              const isFocused = useTabStore.getState().currentTab === tab;
               if (isFocused) {
                 eSendEvent(eOnLoadNote, {
                   item: await db.notes.note(id),
                   forced: true
                 });
               } else {
-                editorController.current.commands.setLoading(true, tab.id);
+                editorController.current.commands.setLoading(true, tab);
               }
-            });
+            }
           });
         close?.();
       },

apps/mobile/app/components/dialog/index.js

@@ -80,9 +80,8 @@ export const Dialog = ({ context = "global" }) => {
         return;
       }
     }
-    setChecked(false);
-    values.current.inputValue = undefined;
-    setVisible(false);
+
+    hide();
   };
 
   const show = useCallback(
@@ -105,14 +104,13 @@ export const Dialog = ({ context = "global" }) => {
       eUnSubscribeEvent(eOpenSimpleDialog, show);
       eUnSubscribeEvent(eCloseSimpleDialog, hide);
     };
-  }, [hide, show]);
+  }, [show]);
 
-  const hide = React.useCallback(() => {
+  const hide = () => {
     setChecked(false);
     values.current.inputValue = undefined;
     setVisible(false);
-    dialogInfo.onClose?.();
-  }, [dialogInfo]);
+  };
 
   const onNegativePress = async () => {
     if (dialogInfo.onClose) {

apps/mobile/app/components/list-items/note/index.tsx

@@ -76,8 +76,7 @@ const NoteItem = ({
 }: NoteItemProps) => {
   const isEditingNote = useTabStore(
     (state) =>
-      state.tabs.find((t) => t.id === state.currentTab)?.session?.noteId ===
-      item.id
+      state.tabs.find((t) => t.id === state.currentTab)?.noteId === item.id
   );
   const { colors } = useThemeColors();
   const compactMode = useIsCompactModeEnabled(

apps/mobile/app/components/list-items/selection-wrapper/back-fill.tsx

@@ -28,8 +28,7 @@ export const Filler = ({ item, color }: { item: Item; color?: string }) => {
   const { colors } = useThemeColors();
   const isEditingNote = useTabStore(
     (state) =>
-      state.tabs.find((t) => t.id === state.currentTab)?.session?.noteId ===
-      item.id
+      state.tabs.find((t) => t.id === state.currentTab)?.noteId === item.id
   );
 
   const [selected] = useIsSelected(item);

apps/mobile/app/components/properties/index.js

@@ -141,7 +141,7 @@ export const Properties = ({ close = () => {}, item, buttons = [] }) => {
                     close();
                     eSendEvent(eOnLoadNote, {
                       item: item,
-                      newTab: true
+                      presistTab: true
                     });
                     if (!DDS.isTab) {
                       tabBarRef.current?.goToPage(1);

apps/mobile/app/components/sheets/editor-tabs/index.tsx

@@ -16,8 +16,8 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-import { EVENTS, Note } from "@notesnook/core";
-import { strings } from "@notesnook/intl";
+import { Note } from "@notesnook/core";
+import { EVENTS } from "@notesnook/core";
 import { useThemeColors } from "@notesnook/theme";
 import React, { useEffect } from "react";
 import { View } from "react-native";
@@ -25,18 +25,27 @@ import { FlatList } from "react-native-actions-sheet";
 import Icon from "react-native-vector-icons/MaterialCommunityIcons";
 import { db } from "../../../common/database";
 import { useDBItem } from "../../../hooks/use-db-item";
-import {
-  TabItem,
-  useTabStore
-} from "../../../screens/editor/tiptap/use-tab-store";
+import { useTabStore } from "../../../screens/editor/tiptap/use-tab-store";
 import { editorController } from "../../../screens/editor/tiptap/utils";
 import { eSendEvent, presentSheet } from "../../../services/event-manager";
 import { eUnlockNote } from "../../../utils/events";
 import { SIZE } from "../../../utils/size";
+import { Button } from "../../ui/button";
 import { IconButton } from "../../ui/icon-button";
 import { Pressable } from "../../ui/pressable";
 import Heading from "../../ui/typography/heading";
 import Paragraph from "../../ui/typography/paragraph";
+import { strings } from "@notesnook/intl";
+
+type TabItem = {
+  id: number;
+  noteId?: string;
+  previewTab?: boolean;
+  locked?: boolean;
+  noteLocked?: boolean;
+  readonly?: boolean;
+  pinned?: boolean;
+};
 
 const TabItemComponent = (props: {
   tab: TabItem;
@@ -44,7 +53,7 @@ const TabItemComponent = (props: {
   close?: (ctx?: string | undefined) => void;
 }) => {
   const { colors } = useThemeColors();
-  const [item, update] = useDBItem(props.tab.session?.noteId, "note");
+  const [item, update] = useDBItem(props.tab.noteId, "note");
 
   useEffect(() => {
     const syncCompletedSubscription = db.eventManager?.subscribe(
@@ -76,11 +85,11 @@ const TabItemComponent = (props: {
       onPress={() => {
         if (!props.isFocused) {
           useTabStore.getState().focusTab(props.tab.id);
-          if (props.tab.session?.locked) {
+          if (props.tab.locked) {
             eSendEvent(eUnlockNote);
           }
 
-          if (!props.tab.session?.noteId) {
+          if (!props.tab.noteId) {
             setTimeout(() => {
               editorController?.current?.commands?.focus(props.tab.id);
             }, 300);
@@ -88,6 +97,11 @@ const TabItemComponent = (props: {
         }
         props.close?.();
       }}
+      onLongPress={() => {
+        useTabStore.getState().updateTab(props.tab.id, {
+          previewTab: false
+        });
+      }}
     >
       <View
         style={{
@@ -98,9 +112,9 @@ const TabItemComponent = (props: {
           flexShrink: 1
         }}
       >
-        {props.tab.session?.noteLocked ? (
+        {props.tab.noteLocked ? (
           <>
-            {props.tab.session?.locked ? (
+            {props.tab.locked ? (
               <Icon size={SIZE.md} name="lock" />
             ) : (
               <Icon size={SIZE.md} name="lock-open-outline" />
@@ -108,9 +122,7 @@ const TabItemComponent = (props: {
           </>
         ) : null}
 
-        {props.tab.session?.readonly ? (
-          <Icon size={SIZE.md} name="pencil-lock" />
-        ) : null}
+        {props.tab.readonly ? <Icon size={SIZE.md} name="pencil-lock" /> : null}
 
         <Paragraph
           color={
@@ -118,10 +130,15 @@ const TabItemComponent = (props: {
               ? colors.selected.paragraph
               : colors.primary.paragraph
           }
+          style={{
+            fontFamily: props.tab.previewTab
+              ? "OpenSans-Italic"
+              : "OpenSans-Regular"
+          }}
           numberOfLines={1}
           size={SIZE.md}
         >
-          {props.tab.session?.noteId
+          {props.tab.noteId
             ? item?.title || strings.untitledNote()
             : strings.newNote()}
         </Paragraph>
@@ -140,7 +157,8 @@ const TabItemComponent = (props: {
           color={props.tab.pinned ? colors.primary.accent : colors.primary.icon}
           onPress={() => {
             useTabStore.getState().updateTab(props.tab.id, {
-              pinned: !props.tab.pinned
+              pinned: !props.tab.pinned,
+              previewTab: false
             });
           }}
           top={0}
@@ -179,7 +197,6 @@ export default function EditorTabs({
 }: {
   close?: (ctx?: string | undefined) => void;
 }) {
-  const { colors } = useThemeColors();
   const [tabs, currentTab] = useTabStore((state) => [
     state.tabs,
     state.currentTab
@@ -216,13 +233,25 @@ export default function EditorTabs({
         }}
       >
         <Heading size={SIZE.lg}>{strings.tabs()}</Heading>
-        <IconButton
+        <Button
           onPress={() => {
             useTabStore.getState().newTab();
+            setTimeout(() => {
+              editorController?.current?.commands?.focus(
+                useTabStore.getState().currentTab
+              );
+            }, 500);
             close?.();
           }}
-          name="plus"
-          color={colors.primary.accent}
+          title={strings.newTab()}
+          icon="plus"
+          style={{
+            flexDirection: "row",
+            justifyContent: "flex-start",
+            borderRadius: 100,
+            height: 35
+          }}
+          iconSize={SIZE.lg}
         />
       </View>
 

apps/mobile/app/components/sheets/link-note/index.tsx

@@ -22,22 +22,24 @@ import {
   VirtualizedGrouping,
   createInternalLink
 } from "@notesnook/core";
-import type { LinkAttributes } from "@notesnook/editor";
-import { NativeEvents } from "@notesnook/editor-mobile/src/utils/native-events";
-import { strings } from "@notesnook/intl";
 import { useThemeColors } from "@notesnook/theme";
 import React, { useEffect, useRef, useState } from "react";
 import { TextInput, View } from "react-native";
 import { FlatList } from "react-native-actions-sheet";
 import { db } from "../../../common/database";
 import { useDBItem } from "../../../hooks/use-db-item";
-import { editorController } from "../../../screens/editor/tiptap/utils";
 import { presentSheet } from "../../../services/event-manager";
 import { SIZE } from "../../../utils/size";
 import { Button } from "../../ui/button";
 import Input from "../../ui/input";
 import { Pressable } from "../../ui/pressable";
 import Paragraph from "../../ui/typography/paragraph";
+import type { LinkAttributes } from "@notesnook/editor";
+import {
+  EditorEvents,
+  editorController
+} from "../../../screens/editor/tiptap/utils";
+import { strings } from "@notesnook/intl";
 
 const ListNoteItem = ({
   id,
@@ -192,7 +194,7 @@ export default function LinkNote(props: {
           }
         : undefined
     );
-    editorController.current?.postMessage(NativeEvents.resolve, {
+    editorController.current?.postMessage(EditorEvents.resolve, {
       data: {
         href: link,
         title: selectedNote.title

apps/mobile/app/components/sheets/update/index.js

@@ -43,7 +43,7 @@ export const Update = ({ version: appVersion, fwdRef }) => {
   let notes = version?.notes
     ? version.notes.replace("Thank you for using Notesnook!", "").split("- ")
     : ["Bug fixes and performance improvements"];
-  notes = notes?.map((n) => n.replace(/\n|<br>/g, ""));
+  notes = notes?.map((n) => n.replace(/\n/g, ""));
   const isGithubRelease = Config.GITHUB_RELEASE === "true";
 
   const getSupportedAbi = () => {
@@ -178,20 +178,18 @@ export const Update = ({ version: appVersion, fwdRef }) => {
                 {version.body}
               </Paragraph>
             ) : null}
-            {notes.map((item) =>
-              item && item !== "" ? (
-                <Paragraph
-                  key={item}
-                  color={colors.secondary.paragraph}
-                  style={{
-                    marginBottom: 5
-                  }}
-                  selectable
-                >
-                  • {item}
-                </Paragraph>
-              ) : null
-            )}
+            {notes.map((item) => (
+              <Paragraph
+                key={item}
+                color={colors.secondary.paragraph}
+                style={{
+                  marginBottom: 5
+                }}
+                selectable
+              >
+                • {item}
+              </Paragraph>
+            ))}
           </ScrollView>
           <Seperator />
           <Button

apps/mobile/app/hooks/use-actions.tsx

@@ -19,14 +19,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* eslint-disable no-inner-declarations */
 import {
   Color,
-  createInternalLink,
   ItemReference,
   Note,
   Notebook,
   Reminder,
   Tag,
   TrashItem,
-  VAULT_ERRORS
+  VAULT_ERRORS,
+  createInternalLink
 } from "@notesnook/core";
 import { strings } from "@notesnook/intl";
 import { DisplayedNotification } from "@notifee/react-native";
@@ -50,11 +50,11 @@ import ReminderSheet from "../components/sheets/reminder";
 import { useSideBarDraggingStore } from "../components/side-menu/dragging-store";
 import { useTabStore } from "../screens/editor/tiptap/use-tab-store";
 import {
+  ToastManager,
   eSendEvent,
   eSubscribeEvent,
   openVault,
-  presentSheet,
-  ToastManager
+  presentSheet
 } from "../services/event-manager";
 import Navigation from "../services/navigation";
 import Notifications from "../services/notifications";
@@ -544,13 +544,14 @@ export const useActions = ({
     const toggleReadyOnlyMode = async () => {
       const currentReadOnly = (item as Note).readonly;
       await db.notes.readonly(!currentReadOnly, item?.id);
-      useTabStore.getState().forEachNoteTab(item.id, (tab) => {
-        useTabStore.getState().updateTab(tab.id, {
-          session: {
-            readonly: !currentReadOnly
-          }
+
+      if (useTabStore.getState().hasTabForNote(item.id)) {
+        const tabId = useTabStore.getState().getTabForNote(item.id);
+        if (!tabId) return;
+        useTabStore.getState().updateTab(tabId, {
+          readonly: !currentReadOnly
         });
-      });
+      }
       Navigation.queueRoutesForUpdate();
       close();
     };

apps/mobile/app/hooks/use-app-events.tsx

@@ -50,17 +50,12 @@ import { MMKV } from "../common/database/mmkv";
 import { endProgress, startProgress } from "../components/dialogs/progress";
 import Migrate from "../components/sheets/migrate";
 import NewFeature from "../components/sheets/new-feature";
-import ReminderSheet from "../components/sheets/reminder";
 import { Walkthrough } from "../components/walkthroughs";
-import {
-  resetTabStore,
-  useTabStore
-} from "../screens/editor/tiptap/use-tab-store";
+import { useTabStore } from "../screens/editor/tiptap/use-tab-store";
 import {
   clearAppState,
   editorController,
-  editorState,
-  setAppState
+  editorState
 } from "../screens/editor/tiptap/utils";
 import { useDragState } from "../screens/settings/editor/state";
 import BackupService from "../services/backup";
@@ -71,6 +66,7 @@ import {
   eSubscribeEvent,
   presentSheet
 } from "../services/event-manager";
+import { IntentService } from "../services/intent";
 import {
   clearMessage,
   setEmailVerifyMessage,
@@ -99,6 +95,7 @@ import {
   eLoginSessionExpired,
   eOnLoadNote,
   eOpenAnnouncementDialog,
+  eUnlockNote,
   eUserLoggedIn,
   refreshNotesPage
 } from "../utils/events";
@@ -106,6 +103,7 @@ import { getGithubVersion } from "../utils/github-version";
 import { tabBarRef } from "../utils/global-refs";
 import { NotesnookModule } from "../utils/notesnook-module";
 import { sleep } from "../utils/time";
+import ReminderSheet from "../components/sheets/reminder";
 
 const onCheckSyncStatus = async (type: SyncStatusEvent) => {
   const { disableSync, disableAutoSync } = SettingsService.get();
@@ -161,6 +159,7 @@ const onUserSessionExpired = async () => {
 const onAppOpenedFromURL = async (event: { url: string }) => {
   const url = event.url;
 
+  console.log("URL", url);
   try {
     if (url.startsWith("https://app.notesnook.com/account/verified")) {
       await onUserEmailVerified();
@@ -245,7 +244,6 @@ const onLogout = async (reason: string) => {
   await PremiumService.setPremiumStatus();
   await BiometricService.resetCredentials();
   MMKV.clearStore();
-  resetTabStore();
   clearAllStores();
   setImmediate(() => {
     refreshAllStores();
@@ -644,17 +642,22 @@ export const useAppEvents = () => {
       EV.subscribe(EVENTS.vaultLocked, async () => {
         // Lock all notes in all tabs...
         for (const tab of useTabStore.getState().tabs) {
-          const noteId = useTabStore.getState().getTab(tab.id)?.session?.noteId;
+          const noteId = useTabStore.getState().getTab(tab.id)?.noteId;
           if (!noteId) continue;
           const note = await db.notes.note(noteId);
           const locked = note && (await db.vaults.itemExists(note));
           if (locked) {
             useTabStore.getState().updateTab(tab.id, {
-              session: {
-                locked: true,
-                noteLocked: true
-              }
+              locked: true
             });
+            if (
+              tab.id === useTabStore.getState().currentTab &&
+              locked &&
+              !editorState().movedAway
+            ) {
+              // Show unlock note screen.
+              eSendEvent(eUnlockNote);
+            }
           }
         }
       }),
@@ -749,15 +752,13 @@ export const useAppEvents = () => {
       setTimeout(() => {
         sub = AppState.addEventListener("change", onAppStateChanged);
         if (
-          refValues.current.initialUrl &&
-          !refValues.current.initialUrl?.includes("open_note")
+          refValues.current.initialUrl?.startsWith(
+            "https://app.notesnook.com/account/verified"
+          )
         ) {
-          onAppOpenedFromURL({
-            url: refValues.current.initialUrl!
-          });
+          onUserEmailVerified();
         }
       }, 1000);
-
       refValues.current.removeInternetStateListener = NetInfo.addEventListener(
         onInternetStateChanged
       );

apps/mobile/app/navigation/navigation-stack.js

@@ -17,7 +17,6 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { strings } from "@notesnook/intl";
 import { useThemeColors } from "@notesnook/theme";
 import { NavigationContainer } from "@react-navigation/native";
 import { createNativeStackNavigator } from "@react-navigation/native-stack";
@@ -45,6 +44,10 @@ import useNavigationStore from "../stores/use-navigation-store";
 import { useSelectionStore } from "../stores/use-selection-store";
 import { useSettingStore } from "../stores/use-setting-store";
 import { rootNavigatorRef } from "../utils/global-refs";
+import { strings } from "@notesnook/intl";
+import { IntentService } from "../services/intent";
+import ReminderSheet from "../components/sheets/reminder";
+import { db } from "../common/database";
 
 const NativeStack = createNativeStackNavigator();
 const IntroStack = createNativeStackNavigator();
@@ -83,6 +86,17 @@ const _Tabs = () => {
   React.useEffect(() => {
     setTimeout(async () => {
       useNavigationStore.getState().update(homepage);
+      const intent = IntentService.getLaunchIntent();
+      if (intent && intent["com.streetwriters.notesnook.OpenReminderId"]) {
+        const reminder = await db.reminders.reminder(
+          intent["com.streetwriters.notesnook.OpenReminderId"]
+        );
+        if (reminder) {
+          ReminderSheet.present(reminder);
+        }
+      } else if (intent["com.streetwriters.notesnook.NewReminder"]) {
+        ReminderSheet.present();
+      }
     }, 1000);
   }, [homepage]);
 

apps/mobile/app/navigation/tabs-holder.js

@@ -509,8 +509,7 @@ const onChangeTab = async (event) => {
       });
     } else {
       if (
-        useTabStore.getState().getTab(useTabStore.getState().currentTab).session
-          ?.locked
+        useTabStore.getState().getTab(useTabStore.getState().currentTab).locked
       ) {
         eSendEvent(eUnlockNote);
       }
@@ -524,15 +523,13 @@ const onChangeTab = async (event) => {
 
       // Lock all tabs with locked notes...
       for (const tab of useTabStore.getState().tabs) {
-        const noteId = useTabStore.getState().getTab(tab.id)?.session?.noteId;
+        const noteId = useTabStore.getState().getTab(tab.id)?.noteId;
         if (!noteId) continue;
         const note = await db.notes.note(noteId);
         const locked = note && (await db.vaults.itemExists(note));
         if (locked) {
           useTabStore.getState().updateTab(tab.id, {
-            session: {
-              locked: true
-            }
+            locked: true
           });
         }
       }

apps/mobile/app/package.json

@@ -39,12 +39,7 @@
     "@lingui/core": "5.1.2",
     "@lingui/react": "5.1.2",
     "react-native-check-version": "^1.3.0",
-    "react-native-material-menu": "^2.0.0",
-    "@trpc/client": "^10.45.2",
-    "@trpc/react-query": "^10.45.2",
-    "@trpc/server": "^10.45.2",
-    "@tanstack/react-query": "^4.36.1",
-    "async-mutex": "0.5.0"
+    "react-native-material-menu": "^2.0.0"
   },
   "sideEffects": false
 }

apps/mobile/app/screens/editor/index.tsx

@@ -19,8 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* eslint-disable @typescript-eslint/no-var-requires */
 
-import { i18n } from "@lingui/core";
-import { strings } from "@notesnook/intl";
 import React, {
   forwardRef,
   useCallback,
@@ -48,7 +46,6 @@ import {
   eUnlockWithPassword
 } from "../../utils/events";
 import { openLinkInBrowser } from "../../utils/functions";
-import { tabBarRef } from "../../utils/global-refs";
 import EditorOverlay from "./loading";
 import { EDITOR_URI } from "./source";
 import { EditorProps, useEditorType } from "./tiptap/types";
@@ -61,6 +58,9 @@ import {
   openInternalLink,
   randId
 } from "./tiptap/utils";
+import { tabBarRef } from "../../utils/global-refs";
+import { strings } from "@notesnook/intl";
+import { i18n } from "@lingui/core";
 
 const style: ViewStyle = {
   height: "100%",
@@ -203,13 +203,11 @@ const useLockedNoteHandler = () => {
 
   useEffect(() => {
     for (const tab of useTabStore.getState().tabs) {
-      const noteId = useTabStore.getState().getTab(tab.id)?.session?.noteId;
+      const noteId = useTabStore.getState().getTab(tab.id)?.noteId;
       if (!noteId) continue;
-      if (tabRef.current && tabRef.current.session?.noteLocked) {
+      if (tabRef.current && tabRef.current.noteLocked) {
         useTabStore.getState().updateTab(tabRef.current.id, {
-          session: {
-            locked: true
-          }
+          locked: true
         });
       }
     }
@@ -223,38 +221,33 @@ const useLockedNoteHandler = () => {
         biometryAvailable: !!biometry,
         biometryEnrolled: !!fingerprint
       });
-      syncTabs("biometry");
+      syncTabs();
     })();
   }, [tab?.id]);
 
   useEffect(() => {
     const unlockWithBiometrics = async () => {
       try {
-        if (!tabRef.current?.session?.noteLocked || !tabRef.current) return;
-        console.log("Trying to unlock with biometrics...");
+        if (!tabRef.current?.noteLocked || !tabRef.current) return;
+
         const credentials = await BiometricService.getCredentials(
           "Unlock note",
           "Unlock note to open it in editor."
         );
 
-        if (
-          credentials &&
-          credentials?.password &&
-          tabRef.current.session?.noteId
-        ) {
+        if (credentials && credentials?.password && tabRef.current.noteId) {
           const note = await db.vault.open(
-            tabRef.current.session?.noteId,
+            tabRef.current.noteId,
             credentials?.password
           );
 
           eSendEvent(eOnLoadNote, {
-            item: note,
-            refresh: true
+            item: note
+          });
+
+          useTabStore.getState().updateTab(tabRef.current.id, {
+            locked: false
           });
-        } else {
-          if (tabRef.current && tabRef.current.session?.locked) {
-            editorController.current?.commands.focusPassInput();
-          }
         }
       } catch (e) {
         console.error(e);
@@ -268,7 +261,7 @@ const useLockedNoteHandler = () => {
       password: string;
       biometrics?: boolean;
     }) => {
-      if (!tabRef.current?.session?.noteId || !tabRef.current) return;
+      if (!tabRef.current?.noteId || !tabRef.current) return;
       if (!password || password.trim().length === 0) {
         ToastManager.show({
           heading: strings.passwordNotEntered(),
@@ -278,10 +271,7 @@ const useLockedNoteHandler = () => {
       }
 
       try {
-        const note = await db.vault.open(
-          tabRef.current?.session?.noteId,
-          password
-        );
+        const note = await db.vault.open(tabRef.current?.noteId, password);
         if (enrollBiometrics && note) {
           try {
             const unlocked = await db.vault.unlock(password);
@@ -309,8 +299,10 @@ const useLockedNoteHandler = () => {
           }
         }
         eSendEvent(eOnLoadNote, {
-          item: note,
-          refresh: true
+          item: note
+        });
+        useTabStore.getState().updateTab(tabRef.current.id, {
+          locked: false
         });
       } catch (e) {
         ToastManager.show({
@@ -322,7 +314,7 @@ const useLockedNoteHandler = () => {
 
     const unlock = () => {
       if (
-        (tabRef.current?.session?.locked,
+        (tabRef.current?.locked,
         useTabStore.getState().biometryAvailable &&
           useTabStore.getState().biometryEnrolled &&
           !editorState().movedAway)
@@ -333,7 +325,7 @@ const useLockedNoteHandler = () => {
       } else {
         if (!editorState().movedAway) {
           setTimeout(() => {
-            if (tabRef.current && tabRef.current?.session?.locked) {
+            if (tabRef.current && tabRef.current?.locked) {
               editorController.current?.commands.focus(tabRef.current?.id);
             }
           }, 100);
@@ -348,13 +340,13 @@ const useLockedNoteHandler = () => {
       }),
       eSubscribeEvent(eUnlockWithPassword, onSubmit)
     ];
-    if (tabRef.current?.session?.locked && tabBarRef.current?.page() === 2) {
+    if (tabRef.current?.locked && tabBarRef.current?.page() === 2) {
       unlock();
     }
     return () => {
       subs.map((s) => s?.unsubscribe());
     };
-  }, [tab?.id, tab?.session?.locked]);
+  }, [tab?.id, tab?.locked]);
 
   return null;
 };

apps/mobile/app/screens/editor/readonly-editor.tsx

@@ -27,10 +27,10 @@ import WebView from "react-native-webview";
 import { useRef } from "react";
 import { EDITOR_URI } from "./source";
 import { EditorMessage } from "./tiptap/types";
-import { EditorEvents } from "@notesnook/editor-mobile/src/utils/editor-events";
+import { EventTypes } from "./tiptap/editor-events";
 import { Attachment } from "@notesnook/editor";
 import downloadAttachment from "../../common/filesystem/download-attachment";
-import { NativeEvents } from "@notesnook/editor-mobile/src/utils/native-events";
+import { EditorEvents } from "./tiptap/utils";
 import { useThemeColors } from "@notesnook/theme";
 import useGlobalSafeAreaInsets from "../../hooks/use-global-safe-area-insets";
 import { db } from "../../common/database";
@@ -69,11 +69,11 @@ export function ReadonlyEditor(props: {
     const data = event.nativeEvent.data;
     const editorMessage = JSON.parse(data) as EditorMessage<any>;
 
-    if (editorMessage.type === EditorEvents.logger) {
+    if (editorMessage.type === EventTypes.logger) {
       logger.info("[READONLY EDITOR LOG]", editorMessage.value);
     }
 
-    if (editorMessage.type === EditorEvents.readonlyEditorLoaded) {
+    if (editorMessage.type === EventTypes.readonlyEditorLoaded) {
       props.onLoad?.((content: { data: string; id: string }) => {
         setTimeout(() => {
           noteId.current = content.id;
@@ -86,7 +86,7 @@ export function ReadonlyEditor(props: {
           setLoading(false);
         }, 300);
       });
-    } else if (editorMessage.type === EditorEvents.getAttachmentData) {
+    } else if (editorMessage.type === EventTypes.getAttachmentData) {
       const attachment = (editorMessage.value as any).attachment as Attachment;
 
       downloadAttachment(attachment.hash, true, {
@@ -104,7 +104,7 @@ export function ReadonlyEditor(props: {
           );
           editorRef.current?.postMessage(
             JSON.stringify({
-              type: NativeEvents.attachmentData,
+              type: EditorEvents.attachmentData,
               value: {
                 resolverId: (editorMessage.value as any).resolverId,
                 data
@@ -115,7 +115,7 @@ export function ReadonlyEditor(props: {
         .catch(() => {
           editorRef.current?.postMessage(
             JSON.stringify({
-              type: NativeEvents.attachmentData,
+              type: EditorEvents.attachmentData,
               data: {
                 resolverId: (editorMessage.value as any).resolverId,
                 data: undefined

apps/mobile/app/screens/editor/tiptap/commands.ts

@@ -18,11 +18,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Note } from "@notesnook/core";
-import type {
-  Attachment,
-  ImageAttributes,
-  LinkAttributes
-} from "@notesnook/editor";
+import type { Attachment } from "@notesnook/editor";
+import type { ImageAttributes } from "@notesnook/editor";
+import type { LinkAttributes } from "@notesnook/editor";
 import { createRef, RefObject } from "react";
 import { Platform } from "react-native";
 import { EdgeInsets } from "react-native-safe-area-context";
@@ -39,6 +37,9 @@ async function call(webview: RefObject<WebView | undefined>, action?: Action) {
   if (!webview.current || !action) return;
   setImmediate(() => webview.current?.injectJavaScript(action.job));
   const response = await getResponse(action.id);
+  // if (!response) {
+  //   console.warn("webview job failed", action.id);
+  // }
   return response ? response.value : response;
 }
 
@@ -74,71 +75,110 @@ class Commands {
     return call(this.ref, fn(job, name)) as Promise<T>;
   }
 
-  async sendCommand<T>(command: string, ...args: any[]) {
-    return this.doAsync(
-      `response = globalThis.commands.${command}(${args
-        .map((arg) =>
-          typeof arg === "string" ? `"${arg}"` : JSON.stringify(arg)
-        )
-        .join(",")})`,
-      command
-    );
-  }
-
-  focus = async (tabId: string) => {
+  focus = async (tabId: number) => {
     if (!this.ref.current) return;
-
-    const locked = useTabStore.getState().getTab(tabId)?.session?.locked;
     if (Platform.OS === "android") {
+      //this.ref.current?.requestFocus();
       setTimeout(async () => {
-        if (
-          locked &&
-          useTabStore.getState().biometryAvailable &&
-          useTabStore.getState().biometryEnrolled
-        )
-          return;
-
         if (!this.ref) return;
         textInput.current?.focus();
-        await this.sendCommand("focus", tabId, locked);
+
+        const locked = useTabStore.getState().getTab(tabId)?.locked;
+        await this.doAsync(
+          locked
+            ? `editorControllers[${tabId}]?.focusPassInput();`
+            : `editors[${tabId}]?.commands.focus()`,
+          "focus"
+        );
+
         this.ref?.current?.requestFocus();
       }, 1);
     } else {
       await sleep(400);
-      await this.sendCommand("focus", tabId, locked);
+      await this.doAsync(`editors[${tabId}]?.commands.focus()`, "focus");
     }
   };
 
-  blur = async (tabId: string) => this.sendCommand("blur", tabId);
+  blur = async (tabId: number) =>
+    await this.doAsync(
+      `
+    const editor = editors[${tabId}];
+    const editorTitle = editorTitles[${tabId}];
+    typeof editor !== "undefined" && editor.commands.blur();
+    typeof editorTitle !== "undefined" && editorTitle.current && editorTitle.current.blur();
+    
+    editorControllers[${tabId}]?.blurPassInput();
 
-  clearContent = async (tabId: string) => {
+  `,
+      "blur"
+    );
+
+  clearContent = async (tabId: number) => {
     this.previousSettings = null;
-    await this.sendCommand("clearContent", tabId);
+    await this.doAsync(
+      `
+const editor = editors[${tabId}];
+const editorController = editorControllers[${tabId}];
+const editorTitle = editorTitles[${tabId}];
+const statusBar = statusBars[${tabId}];
+
+if (typeof editor !== "undefined") {
+  editor.commands.blur();
+  editor.commands.clearContent(false);
+}
+
+typeof editorTitle !== "undefined" && editorTitle.current && editorTitle.current?.blur();
+if (typeof editorController.content !== undefined) editorController.content.current = '';
+editorController.onUpdate();
+editorController.setTitle('');
+if (typeof statusBar !== "undefined") {
+  statusBar.current.resetWords();
+  statusBar.current.set({date:"",saved:""});
+}`,
+      "clearContent"
+    );
   };
 
   setSessionId = async (id: string | null) =>
-    await this.sendCommand("setSessionId", id);
+    await this.doAsync(`globalThis.sessionId = "${id}";`);
 
   setStatus = async (
     date: string | undefined,
     saved: string,
-    tabId: string
+    tabId: number
   ) => {
-    this.sendCommand("setStatus", date, saved, tabId);
-  };
-
-  setPlaceholder = async (placeholder: string) => {};
-
-  setLoading = async (loading?: boolean, tabId?: string) => {
-    this.sendCommand(
-      "setLoading",
-      loading,
-      tabId === undefined ? useTabStore.getState().currentTab : tabId
+    await this.doAsync(
+      `
+      const statusBar = statusBars[${tabId}];
+      typeof statusBar !== "undefined" && statusBar.current.set({date:"${date}",saved:"${saved}"})`,
+      "setStatus"
     );
   };
 
+  setPlaceholder = async (placeholder: string) => {
+    // await this.doAsync(`
+    // const element = document.querySelector(".is-editor-empty");
+    // if (element) {
+    //   element.setAttribute("data-placeholder","${placeholder}");
+    // }
+    // `);
+  };
+
+  setLoading = async (loading?: boolean, tabId?: number) => {
+    await this.doAsync(`
+    const editorController = editorControllers[${
+      tabId || useTabStore.getState().currentTab
+    }];
+    editorController.setLoading(${loading})
+    `);
+  };
+
   setInsets = async (insets: EdgeInsets) => {
-    this.sendCommand("setInsets", insets);
+    await this.doAsync(`
+      if (typeof safeAreaController !== "undefined") {
+        safeAreaController.update(${JSON.stringify(insets)}) 
+      }
+    `);
   };
 
   updateSettings = async (settings?: Partial<Settings>) => {
@@ -147,7 +187,13 @@ class Commands {
       ...this.previousSettings,
       ...settings
     };
-    this.sendCommand("updateSettings", settings);
+    await this.doAsync(`
+      if (typeof globalThis.settingsController !== "undefined") {
+        globalThis.settingsController.update(${JSON.stringify(
+          this.previousSettings
+        )}) 
+      }
+    `);
   };
 
   setSettings = async (settings?: Partial<Settings>) => {
@@ -160,63 +206,123 @@ class Commands {
         return;
       }
     }
-    this.sendCommand("setSettings", settings);
+    await this.doAsync(`
+      if (typeof globalThis.settingsController !== "undefined") {
+        globalThis.settingsController.update(${JSON.stringify(settings)}) 
+      }
+    `);
   };
 
   setTags = async (note: Note | null | undefined) => {
     if (!note) return;
-    useTabStore.getState().forEachNoteTab(note.id, async (tab) => {
-      const tabId = tab.id;
-      const tags = await db.relations.to(note, "tag").resolve();
-      await this.sendCommand("setTags", tabId, tags);
-    });
+    const tabId = useTabStore.getState().getTabForNote(note.id);
+
+    const tags = await db.relations.to(note, "tag").resolve();
+    await this.doAsync(
+      `
+    const tags = editorTags[${tabId}];
+    if (tags && tags.current) {
+      tags.current.setTags(${JSON.stringify(
+        tags.map((tag) => ({
+          title: tag.title,
+          alias: tag.title,
+          id: tag.id,
+          type: tag.type
+        }))
+      )});
+    }
+  `,
+      "setTags"
+    );
   };
 
-  clearTags = async (tabId: string) => {
-    await this.sendCommand("clearTags", tabId);
+  clearTags = async (tabId: number) => {
+    await this.doAsync(
+      `
+    const tags = editorTags[${tabId}];
+    logger("info", Object.keys(editorTags), typeof editorTags[0]);
+    if (tags && tags.current) {
+      tags.current.setTags([]);
+    }
+  `,
+      "clearTags"
+    );
   };
 
-  insertAttachment = async (attachment: Attachment, tabId: string) => {
-    await this.sendCommand("insertAttachment", attachment, tabId);
+  insertAttachment = async (attachment: Attachment, tabId: number) => {
+    await this.doAsync(
+      `const editor = editors[${tabId}];
+editor && editor.commands.insertAttachment(${JSON.stringify(attachment)})`
+    );
   };
 
   setAttachmentProgress = async (
     attachmentProgress: Partial<Attachment>,
-    tabId: string
+    tabId: number
   ) => {
-    await this.sendCommand("setAttachmentProgress", attachmentProgress, tabId);
+    await this.doAsync(
+      `const editor = editors[${tabId}];
+editor && editor.commands.updateAttachment(${JSON.stringify(
+        attachmentProgress
+      )}, {
+        preventUpdate: true,
+        query: (attachment) => {
+          return attachment.hash === "${attachmentProgress.hash}";
+        }
+      })`
+    );
   };
 
   insertImage = async (
     image: Omit<ImageAttributes, "bloburl"> & {
       dataurl: string;
     },
-    tabId: string
+    tabId: number
   ) => {
-    await this.sendCommand("insertImage", image, tabId);
+    await this.doAsync(
+      `const editor = editors[${tabId}];
+
+const image = toBlobURL("${image.dataurl}", "${image.hash}");
+
+editor && editor.commands.insertImage({
+        ...${JSON.stringify({
+          ...image,
+          dataurl: undefined
+        })},
+        bloburl: image
+      })`
+    );
   };
 
   handleBack = async () => {
-    return this.sendCommand("handleBack");
+    return this.doAsync<boolean>(
+      'response = window.dispatchEvent(new Event("handleBackPress",{cancelable:true}));'
+    );
   };
 
   keyboardShown = async (keyboardShown: boolean) => {
-    return this.sendCommand("keyboardShown", keyboardShown);
+    return this.doAsync(`globalThis['keyboardShown']=${keyboardShown};`);
   };
 
   getTableOfContents = async () => {
     const tabId = useTabStore.getState().currentTab;
-    return this.sendCommand("getTableOfContents", tabId);
+    return this.doAsync(`
+      response = editorControllers[${tabId}]?.getTableOfContents() || [];
+    `);
   };
 
   focusPassInput = async () => {
     const tabId = useTabStore.getState().currentTab;
-    return this.sendCommand("focusPassInput", tabId);
+    return this.doAsync(`
+      response = editorControllers[${tabId}]?.focusPassInput() || [];
+    `);
   };
 
   blurPassInput = async () => {
     const tabId = useTabStore.getState().currentTab;
-    return this.sendCommand("blurPassInput", tabId);
+    return this.doAsync(`
+      response = editorControllers[${tabId}]?.blurPassInput() || [];
+    `);
   };
 
   createInternalLink = async (
@@ -224,18 +330,30 @@ class Commands {
     resolverId: string
   ) => {
     if (!resolverId) return;
-    return this.sendCommand("createInternalLink", attributes, resolverId);
+    return this.doAsync(`
+    if (globalThis.pendingResolvers["${resolverId}"]) {
+      globalThis.pendingResolvers["${resolverId}"](${JSON.stringify(
+      attributes
+    )});
+    }`);
   };
 
   dismissCreateInternalLinkRequest = async (resolverId: string) => {
     if (!resolverId) return;
-    return this.sendCommand("dismissCreateInternalLinkRequest", resolverId);
+    return this.doAsync(`
+    if (globalThis.pendingResolvers["${resolverId}"]) {
+      globalThis.pendingResolvers["${resolverId}"](undefined);
+    }
+    `);
   };
 
   scrollIntoViewById = async (id: string) => {
     const tabId = useTabStore.getState().currentTab;
-    return this.sendCommand("scrollIntoViewById", id, tabId);
+    return this.doAsync(`
+      response = editorControllers[${tabId}]?.scrollIntoView("${id}") || [];
+    `);
   };
+  //todo add replace image function
 }
 
 export default Commands;

apps/mobile/app/screens/editor/tiptap/editor-events.ts

@@ -16,8 +16,7 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-
-export const EditorEvents = {
+export const EventTypes = {
   selection: "editor-event:selection",
   content: "editor-event:content",
   title: "editor-event:title",
@@ -50,9 +49,5 @@ export const EditorEvents = {
   disableReadonlyMode: "editor-events:disable-readonly-mode",
   readonlyEditorLoaded: "readonlyEditorLoaded",
   error: "editorError",
-  dbLogger: "editor-events:dbLogger",
-  goBack: "editor-events:go-back",
-  goForward: "editor-events:go-forward",
-  saveScroll: "editor-events:save-scroll",
-  newNote: "editor-events:new-note"
-} as const;
+  dbLogger: "editor-events:dbLogger"
+};

apps/mobile/app/screens/editor/tiptap/picker.ts

@@ -44,6 +44,7 @@ import { useTabStore } from "./use-tab-store";
 import { editorController, editorState } from "./utils";
 import { strings } from "@notesnook/intl";
 import { useUserStore } from "../../../stores/use-user-store";
+import { sleep } from "../../../utils/time";
 
 const showEncryptionSheet = (file: DocumentPickerResponse) => {
   presentSheet({
@@ -61,7 +62,7 @@ const santizeUri = (uri: string) => {
 
 type PickerOptions = {
   noteId?: string;
-  tabId?: string;
+  tabId?: number;
   type: "image" | "camera" | "file";
   reupload: boolean;
   hash?: string;
@@ -132,6 +133,7 @@ const file = async (fileOptions: PickerOptions) => {
 
     if (
       fileOptions.tabId !== undefined &&
+      fileOptions.noteId &&
       useTabStore.getState().getNoteIdForTab(fileOptions.tabId) ===
         fileOptions.noteId
     ) {

apps/mobile/app/screens/editor/tiptap/types.ts

@@ -74,7 +74,7 @@ export type EditorMessage<T> = {
   value: T;
   type: string;
   noteId: string;
-  tabId: string;
+  tabId: number;
   resolverId?: string;
   hasTimeout?: boolean;
 };
@@ -86,7 +86,7 @@ export type SavePayload = {
   type?: "tiptap";
   sessionHistoryId?: number;
   ignoreEdit: boolean;
-  tabId: string;
+  tabId: number;
   pendingChanges?: boolean;
 };
 

apps/mobile/app/screens/editor/tiptap/use-editor-events.tsx

@@ -21,10 +21,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* eslint-disable @typescript-eslint/no-var-requires */
 import { ItemReference } from "@notesnook/core";
 import type { Attachment } from "@notesnook/editor";
-import { EditorEvents } from "@notesnook/editor-mobile/src/utils/editor-events";
-import { NativeEvents } from "@notesnook/editor-mobile/src/utils/native-events";
 import { getDefaultPresets } from "@notesnook/editor/dist/cjs/toolbar/tool-definitions";
-import { strings } from "@notesnook/intl";
 import Clipboard from "@react-native-clipboard/clipboard";
 import React, { useCallback, useEffect, useRef } from "react";
 import {
@@ -75,9 +72,11 @@ import {
 import { openLinkInBrowser } from "../../../utils/functions";
 import { tabBarRef } from "../../../utils/global-refs";
 import { useDragState } from "../../settings/editor/state";
+import { EventTypes } from "./editor-events";
 import { EditorMessage, EditorProps, useEditorType } from "./types";
 import { useTabStore } from "./use-tab-store";
-import { editorState, openInternalLink } from "./utils";
+import { EditorEvents, editorState, openInternalLink } from "./utils";
+import { strings } from "@notesnook/intl";
 
 const publishNote = async () => {
   const user = useUserStore.getState().user;
@@ -102,7 +101,7 @@ const publishNote = async () => {
   }
   const noteId = useTabStore
     .getState()
-    .getNoteIdForTab(useTabStore.getState().currentTab!);
+    .getNoteIdForTab(useTabStore.getState().currentTab);
 
   if (noteId) {
     const note = await db.notes?.note(noteId);
@@ -125,7 +124,7 @@ const publishNote = async () => {
 const showActionsheet = async () => {
   const noteId = useTabStore
     .getState()
-    .getNoteIdForTab(useTabStore.getState().currentTab!);
+    .getNoteIdForTab(useTabStore.getState().currentTab);
   if (noteId) {
     const note = await db.notes?.note(noteId);
     if (editorState().isFocused || editorState().isFocused) {
@@ -178,7 +177,7 @@ export const useEditorEvents = (
   useEffect(() => {
     const handleKeyboardDidShow: KeyboardEventListener = () => {
       editor.commands.keyboardShown(true);
-      editor.postMessage(NativeEvents.keyboardShown, undefined);
+      editor.postMessage(EditorEvents.keyboardShown, undefined);
     };
     const handleKeyboardDidHide: KeyboardEventListener = () => {
       editor.commands.keyboardShown(false);
@@ -248,7 +247,7 @@ export const useEditorEvents = (
     }
     editorState().currentlyEditing = false;
     // editor.reset(); Notes remain open.
-    editor.commands?.blur(useTabStore.getState().currentTab!);
+    editor.commands?.blur(useTabStore.getState().currentTab);
     setTimeout(async () => {
       if (deviceMode !== "mobile" && fullscreen) {
         if (fullscreen) {
@@ -353,25 +352,25 @@ export const useEditorEvents = (
       const editorMessage = JSON.parse(data) as EditorMessage<any>;
 
       if (editorMessage.hasTimeout && editorMessage.resolverId) {
-        editor.postMessage(NativeEvents.resolve, {
+        editor.postMessage(EditorEvents.resolve, {
           data: true,
           resolverId: editorMessage.resolverId
         });
       }
 
-      if (editorMessage.type === EditorEvents.load) {
+      if (editorMessage.type === EventTypes.load) {
         DatabaseLogger.log("Editor is ready");
         editor.onLoad();
         return;
       }
 
-      if (editorMessage.type === EditorEvents.back) {
+      if (editorMessage.type === EventTypes.back) {
         return onBackPress();
       }
 
       if (
         editorMessage.sessionId !== editor.sessionId.current &&
-        editorMessage.type !== NativeEvents.status
+        editorMessage.type !== EditorEvents.status
       ) {
         return;
       }
@@ -381,8 +380,8 @@ export const useEditorEvents = (
         .getNoteIdForTab(editorMessage.tabId);
 
       switch (editorMessage.type) {
-        case EditorEvents.content:
-          DatabaseLogger.log("EditorEvents.content");
+        case EventTypes.content:
+          DatabaseLogger.log("EventTypes.content");
           editor.saveContent({
             type: editorMessage.type,
             content: editorMessage.value.html as string,
@@ -392,8 +391,8 @@ export const useEditorEvents = (
             pendingChanges: editorMessage.value?.pendingChanges
           });
           break;
-        case EditorEvents.title:
-          DatabaseLogger.log("EditorEvents.title");
+        case EventTypes.title:
+          DatabaseLogger.log("EventTypes.title");
           editor.saveContent({
             type: editorMessage.type,
             title: editorMessage.value?.title as string,
@@ -403,10 +402,10 @@ export const useEditorEvents = (
             pendingChanges: editorMessage.value?.pendingChanges
           });
           break;
-        case EditorEvents.logger:
+        case EventTypes.logger:
           logger.info("[EDITOR LOG]", editorMessage.value);
           break;
-        case EditorEvents.dbLogger:
+        case EventTypes.dbLogger:
           if (editorMessage.value.error) {
             DatabaseLogger.error(
               editorMessage.value.error,
@@ -419,12 +418,12 @@ export const useEditorEvents = (
             DatabaseLogger.info("[EDITOR_LOG]" + editorMessage.value.message);
           }
           break;
-        case EditorEvents.contentchange:
+        case EventTypes.contentchange:
           editor.onContentChanged(editorMessage.noteId);
           break;
-        case EditorEvents.selection:
+        case EventTypes.selection:
           break;
-        case EditorEvents.reminders:
+        case EventTypes.reminders:
           if (!noteId) {
             ToastManager.show({
               heading: strings.createNoteFirst(),
@@ -442,7 +441,7 @@ export const useEditorEvents = (
             onAdd: () => ReminderSheet.present(undefined, note, true)
           });
           break;
-        case EditorEvents.newtag:
+        case EventTypes.newtag:
           if (!noteId) {
             ToastManager.show({
               heading: strings.createNoteFirst(),
@@ -452,7 +451,7 @@ export const useEditorEvents = (
           }
           ManageTagsSheet.present([noteId]);
           break;
-        case EditorEvents.tag:
+        case EventTypes.tag:
           if (editorMessage.value) {
             if (!noteId) return;
             const note = await db.notes.note(noteId);
@@ -468,7 +467,7 @@ export const useEditorEvents = (
               });
           }
           break;
-        case EditorEvents.filepicker:
+        case EventTypes.filepicker:
           editorState().isAwaitingResult = true;
           const { pick } = require("./picker").default;
           pick({
@@ -480,14 +479,14 @@ export const useEditorEvents = (
             editorState().isAwaitingResult = false;
           }, 1000);
           break;
-        case EditorEvents.download: {
+        case EventTypes.download: {
           const downloadAttachment =
             require("../../../common/filesystem/download-attachment").default;
           downloadAttachment((editorMessage.value as Attachment)?.hash, true);
           break;
         }
 
-        case EditorEvents.getAttachmentData: {
+        case EventTypes.getAttachmentData: {
           const attachment = (editorMessage.value as any)
             ?.attachment as Attachment;
 
@@ -507,14 +506,14 @@ export const useEditorEvents = (
                 !!data,
                 editorMessage.resolverId
               );
-              editor.postMessage(NativeEvents.resolve, {
+              editor.postMessage(EditorEvents.resolve, {
                 resolverId: editorMessage.resolverId,
                 data
               });
             })
             .catch((e) => {
               DatabaseLogger.error(e);
-              editor.postMessage(NativeEvents.resolve, {
+              editor.postMessage(EditorEvents.resolve, {
                 resolverId: editorMessage.resolverId,
                 data: undefined
               });
@@ -523,26 +522,26 @@ export const useEditorEvents = (
           break;
         }
 
-        case EditorEvents.pro:
+        case EventTypes.pro:
           if (editor.state.current?.isFocused) {
             editor.state.current.isFocused = true;
           }
           eSendEvent(eOpenPremiumDialog);
           break;
-        case EditorEvents.monograph:
+        case EventTypes.monograph:
           publishNote();
           break;
-        case EditorEvents.properties:
+        case EventTypes.properties:
           showActionsheet();
           break;
-        case EditorEvents.scroll:
+        case EventTypes.scroll:
           editorState().scrollPosition = editorMessage.value;
           break;
-        case EditorEvents.fullscreen:
+        case EventTypes.fullscreen:
           editorState().isFullscreen = true;
           eSendEvent(eOpenFullscreenEditor);
           break;
-        case EditorEvents.link:
+        case EventTypes.link:
           if (editorMessage.value.startsWith("nn://")) {
             openInternalLink(editorMessage.value);
             console.log(
@@ -554,7 +553,7 @@ export const useEditorEvents = (
           }
           break;
 
-        case EditorEvents.previewAttachment: {
+        case EventTypes.previewAttachment: {
           const hash = (editorMessage.value as Attachment)?.hash;
           const attachment = await db.attachments?.attachment(hash);
           if (!attachment) return;
@@ -565,26 +564,11 @@ export const useEditorEvents = (
           }
           break;
         }
-        case EditorEvents.copyToClipboard: {
+        case EventTypes.copyToClipboard: {
           Clipboard.setString(editorMessage.value as string);
           break;
         }
-        case EditorEvents.saveScroll: {
-          useTabStore.getState().updateTab(editorMessage.tabId, {
-            session: {
-              ...editorMessage.value
-            }
-          });
-          break;
-        }
-        case EditorEvents.newNote: {
-          eSendEvent(eOnLoadNote, {
-            tabId: editorMessage.tabId,
-            newNote: true
-          });
-          break;
-        }
-        case EditorEvents.tabsChanged: {
+        case EventTypes.tabsChanged: {
           // useTabStore.setState({
           //   tabs: (editorMessage.value as any)?.tabs,
           //   currentTab: (editorMessage.value as any)?.currentTab
@@ -592,14 +576,14 @@ export const useEditorEvents = (
           //
           break;
         }
-        case EditorEvents.toc:
+        case EventTypes.toc:
           TableOfContents.present(editorMessage.value);
           break;
-        case EditorEvents.showTabs: {
+        case EventTypes.showTabs: {
           EditorTabs.present();
           break;
         }
-        case EditorEvents.error: {
+        case EventTypes.error: {
           presentSheet({
             component: (
               <Issue
@@ -611,15 +595,19 @@ export const useEditorEvents = (
           });
           break;
         }
-        case EditorEvents.tabFocused: {
+        case EventTypes.tabFocused: {
           eSendEvent(eEditorTabFocused, editorMessage.tabId);
-          if (!editor.state.current.initialLoadCalled) break;
-          if (editorMessage.noteId) {
+
+          if (
+            (!editorMessage.value || editor.currentLoadingNoteId.current) &&
+            editorMessage.noteId
+          ) {
             if (!useSettingStore.getState().isAppLoading) {
               const note = await db.notes.note(editorMessage.noteId);
               if (note) {
                 eSendEvent(eOnLoadNote, {
                   item: note,
+                  forced: true,
                   tabId: editorMessage.tabId
                 });
               }
@@ -631,6 +619,7 @@ export const useEditorEvents = (
                   if (note) {
                     eSendEvent(eOnLoadNote, {
                       item: note,
+                      forced: true,
                       tabId: editorMessage.tabId
                     });
                   }
@@ -641,7 +630,7 @@ export const useEditorEvents = (
 
           break;
         }
-        case EditorEvents.createInternalLink: {
+        case EventTypes.createInternalLink: {
           LinkNote.present(
             editorMessage.value.attributes,
             editorMessage.resolverId as string
@@ -649,37 +638,25 @@ export const useEditorEvents = (
           break;
         }
 
-        case EditorEvents.unlock: {
+        case EventTypes.unlock: {
           eSendEvent(eUnlockWithPassword, editorMessage.value);
           break;
         }
 
-        case EditorEvents.goBack: {
-          useTabStore.getState().goBack();
-          break;
-        }
-
-        case EditorEvents.goForward: {
-          useTabStore.getState().goForward();
-          break;
-        }
-
-        case EditorEvents.unlockWithBiometrics: {
+        case EventTypes.unlockWithBiometrics: {
           eSendEvent(eUnlockWithBiometrics);
           break;
         }
 
-        case EditorEvents.disableReadonlyMode: {
+        case EventTypes.disableReadonlyMode: {
           const noteId = editorMessage.value;
           if (noteId) {
             await db.notes.readonly(false, noteId);
             editor.note.current[noteId] = await db.notes?.note(noteId);
             useTabStore
               .getState()
-              .updateTab(useTabStore.getState().currentTab!, {
-                session: {
-                  readonly: false
-                }
+              .updateTab(useTabStore.getState().currentTab, {
+                readonly: false
               });
             setTimeout(() => {
               Navigation.queueRoutesForUpdate();

apps/mobile/app/screens/editor/tiptap/use-editor.ts

@@ -32,11 +32,8 @@ import {
   isEncryptedContent,
   isTrashItem
 } from "@notesnook/core";
-import { EditorEvents } from "@notesnook/editor-mobile/src/utils/editor-events";
-import { NativeEvents } from "@notesnook/editor-mobile/src/utils/native-events";
 import { strings } from "@notesnook/intl";
 import { useThemeEngineStore } from "@notesnook/theme";
-import { Mutex } from "async-mutex";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import WebView from "react-native-webview";
 import { DatabaseLogger, db } from "../../../common/database";
@@ -66,10 +63,12 @@ import { sleep } from "../../../utils/time";
 import { unlockVault } from "../../../utils/unlock-vault";
 import { onNoteCreated } from "../../notes/common";
 import Commands from "./commands";
+import { EventTypes } from "./editor-events";
 import { SessionHistory } from "./session-history";
 import { EditorState, SavePayload } from "./types";
-import { TabSessionItem, syncTabs, useTabStore } from "./use-tab-store";
+import { syncTabs, useTabStore } from "./use-tab-store";
 import {
+  EditorEvents,
   clearAppState,
   defaultState,
   getAppState,
@@ -77,63 +76,11 @@ import {
   isEditorLoaded,
   post
 } from "./utils";
-import { Linking } from "react-native";
-
-const loadNoteMutex = new Mutex();
 
 type NoteWithContent = Note & {
   content?: NoteContent<false>;
 };
 
-type LocalTabStateT = {
-  editedAt: number;
-  lastFocusedAt: number;
-};
-
-class LocalTabState {
-  state: Record<string, LocalTabStateT> = {};
-  noteEditedTime: Record<string, number> = {};
-
-  setEditTime(noteId: string, time: number) {
-    this.noteEditedTime[noteId] = time;
-  }
-
-  get(tabId: string) {
-    return this.state[tabId] || {};
-  }
-
-  set(tabId: string, state: Partial<LocalTabStateT>) {
-    this.state[tabId] = {
-      ...this.state[tabId],
-      ...state
-    };
-  }
-
-  clear(tabId: string) {
-    delete this.state[tabId];
-  }
-
-  reset() {
-    this.state = {};
-  }
-
-  needsRefresh(tabId: string, locked: boolean, readonly: boolean) {
-    const state = this.get(tabId);
-    const tabSession = useTabStore.getState().getTab(tabId)?.session;
-    const noteId = useTabStore.getState().getNoteIdForTab(tabId);
-
-    if (
-      tabSession?.locked !== locked ||
-      tabSession?.readonly !== readonly ||
-      !noteId
-    ) {
-      return true;
-    }
-
-    return !state.editedAt || state.editedAt < this.noteEditedTime[noteId];
-  }
-}
-
 export const useEditor = (
   editorId = "",
   readonly?: boolean,
@@ -152,6 +99,7 @@ export const useEditor = (
             isPreview?: boolean;
           };
         })
+      | null
       | undefined
     >
   >({});
@@ -171,17 +119,15 @@ export const useEditor = (
   const lastContentChangeTime = useRef<Record<string, number>>({});
   const lock = useRef(false);
   const currentLoadingNoteId = useRef<string>();
-  const lastTabFocused = useRef<string>();
-
-  const localTabState = useRef<LocalTabState>(new LocalTabState());
-
+  const loadingState = useRef<string>();
+  const lastTabFocused = useRef(0);
   const blockIdRef = useRef<string>();
   const postMessage = useCallback(
-    async <T>(type: string, data: T, tabId?: string, waitFor = 300) =>
+    async <T>(type: string, data: T, tabId?: number, waitFor = 300) =>
       await post(
         editorRef,
         sessionIdRef.current,
-        tabId || useTabStore.getState().currentTab!,
+        typeof tabId !== "number" ? useTabStore.getState().currentTab : tabId,
         type,
         data,
         waitFor
@@ -196,7 +142,7 @@ export const useEditor = (
   }, [commands, insets, isDefaultEditor]);
 
   useEffect(() => {
-    postMessage(NativeEvents.theme, theme);
+    postMessage(EditorEvents.theme, theme);
   }, [theme, postMessage]);
 
   useEffect(() => {
@@ -206,14 +152,14 @@ export const useEditor = (
   }, [commands, tags]);
 
   useEffect(() => {
-    const event = eSubscribeEvent(eEditorTabFocused, (tabId: string) => {
+    const event = eSubscribeEvent(eEditorTabFocused, (tabId) => {
       if (lastTabFocused.current !== tabId) lock.current = false;
-      lastTabFocused.current = tabId;
+      lastTabFocused.current = tabId as number;
     });
     return () => {
       event?.unsubscribe();
     };
-  }, []);
+  });
 
   const overlay = useCallback(
     (show: boolean, data = { type: "new" }) => {
@@ -242,11 +188,11 @@ export const useEditor = (
   );
 
   const reset = useCallback(
-    async (tabId: string, resetState = true, resetContent = true) => {
+    async (tabId: number, resetState = true, resetContent = true) => {
       const noteId = useTabStore.getState().getNoteIdForTab(tabId);
       if (noteId) {
         currentNotes.current?.id && db.fs().cancel(noteId);
-        currentNotes.current[noteId] = undefined;
+        currentNotes.current[noteId] = null;
         currentContents.current[noteId] = null;
         editorSessionHistory.clearSession(noteId);
         lastContentChangeTime.current[noteId] = 0;
@@ -254,11 +200,18 @@ export const useEditor = (
       }
 
       saveCount.current = 0;
-      currentLoadingNoteId.current = undefined;
+      loadingState.current = undefined;
       lock.current = false;
-      resetContent && postMessage(NativeEvents.title, "", tabId);
+      resetContent && postMessage(EditorEvents.title, "", tabId);
+
       resetContent && (await commands.clearContent(tabId));
       resetContent && (await commands.clearTags(tabId));
+      useTabStore.getState().updateTab(tabId, {
+        noteId: undefined,
+        locked: false,
+        noteLocked: false,
+        readonly: false
+      });
     },
     [commands, editorSessionHistory, postMessage]
   );
@@ -278,16 +231,6 @@ export const useEditor = (
       try {
         if (id && !(await db.notes?.note(id))) {
           await reset(tabId);
-          useTabStore.getState().updateTab(tabId, {
-            session: {
-              noteId: undefined,
-              noteLocked: undefined,
-              locked: undefined,
-              readonly: undefined,
-              scrollTop: undefined,
-              selection: undefined
-            }
-          });
           return;
         }
         let note = id ? await db.notes?.note(id) : undefined;
@@ -326,6 +269,13 @@ export const useEditor = (
           };
         }
 
+        // If note is edited, the tab becomes a persistent tab automatically.
+        if (useTabStore.getState().getTab(tabId)?.previewTab) {
+          useTabStore.getState().updateTab(tabId, {
+            previewTab: false
+          });
+        }
+
         let saved = false;
         setTimeout(() => {
           if (saved) return;
@@ -360,9 +310,7 @@ export const useEditor = (
             }
 
             useTabStore.getState().updateTab(tabId, {
-              session: {
-                noteId: id
-              }
+              noteId: id
             });
 
             const defaultNotebook = db.settings.getDefaultNotebook();
@@ -377,7 +325,7 @@ export const useEditor = (
 
             if (!noteData.title) {
               postMessage(
-                NativeEvents.title,
+                EditorEvents.title,
                 currentNotes.current[id]?.title,
                 tabId
               );
@@ -437,8 +385,8 @@ export const useEditor = (
           id === useTabStore.getState().getCurrentNoteId() &&
           pendingChanges
         ) {
-          postMessage(NativeEvents.title, title || note?.title, tabId);
-          postMessage(NativeEvents.html, data, tabId);
+          postMessage(EditorEvents.title, title || note?.title, tabId);
+          postMessage(EditorEvents.html, data, tabId);
           currentNotes.current[id] = note;
         }
 
@@ -487,222 +435,179 @@ export const useEditor = (
   );
 
   const loadNote = useCallback(
-    (event: {
+    async (event: {
       item?: Note;
+      forced?: boolean;
       newNote?: boolean;
-      tabId?: string;
+      tabId?: number;
       blockId?: string;
-      session?: TabSessionItem;
-      newTab?: boolean;
-      refresh?: boolean;
+      presistTab?: boolean;
     }) => {
-      loadNoteMutex.runExclusive(async () => {
-        if (!event) return;
-        if (event.blockId) {
-          blockIdRef.current = event.blockId;
+      if (!event) return;
+
+      if (event.blockId) {
+        blockIdRef.current = event.blockId;
+      }
+      state.current.currentlyEditing = true;
+
+      if (
+        !state.current.ready &&
+        (await isEditorLoaded(
+          editorRef,
+          sessionIdRef.current,
+          useTabStore.getState().currentTab
+        ))
+      ) {
+        state.current.ready = true;
+      }
+
+      if (event.newNote) {
+        useTabStore.getState().focusEmptyTab();
+        const tabId = useTabStore.getState().currentTab;
+        currentNotes.current && (await reset(tabId));
+        setTimeout(() => {
+          if (state.current?.ready && !state.current.movedAway)
+            commands.focus(tabId);
+        });
+      } else {
+        if (!event.item) {
+          overlay(false);
+          return;
         }
-        state.current.currentlyEditing = true;
 
-        if (
-          !state.current.ready &&
-          (await isEditorLoaded(
-            editorRef,
-            sessionIdRef.current,
-            useTabStore.getState().currentTab!
-          ))
-        ) {
-          state.current.ready = true;
+        const item = event.item;
+
+        const currentTab = useTabStore
+          .getState()
+          .getTab(useTabStore.getState().currentTab);
+        if (currentTab?.previewTab && item.id !== currentTab.noteId) {
+          await commands.setLoading(true, useTabStore.getState().currentTab);
         }
-        if (event.newNote && !currentLoadingNoteId.current) {
-          let tabId;
+        const isLockedNote = await db.vaults.itemExists(
+          event.item as ItemReference
+        );
+        const tabLocked =
+          isLockedNote && !(event.item as NoteWithContent).content;
 
-          const currentTab = useTabStore
-            .getState()
-            .getTab(useTabStore.getState().currentTab as string);
-
-          if (useTabStore.getState().tabs.length === 0 || currentTab?.pinned) {
-            tabId = useTabStore.getState().newTab();
+        // If note was already opened in a tab, focus that tab.
+        if (typeof event.tabId !== "number") {
+          if (useTabStore.getState().hasTabForNote(event.item.id)) {
+            const tabId = useTabStore.getState().getTabForNote(event.item.id);
+            if (typeof tabId === "number") {
+              useTabStore.getState().updateTab(tabId, {
+                readonly: event.item.readonly || readonly,
+                locked: tabLocked,
+                noteLocked: isLockedNote
+              });
+              useTabStore.getState().focusTab(tabId);
+              setTimeout(() => {
+                if (blockIdRef.current) {
+                  commands.scrollIntoViewById(blockIdRef.current);
+                  blockIdRef.current = undefined;
+                }
+              }, 150);
+            }
           } else {
-            tabId = useTabStore.getState().currentTab;
-            await reset(tabId!, true, true);
-            if (
-              event.session?.noteId ||
-              useTabStore.getState().getTab(tabId!)?.session?.noteId
-            ) {
-              useTabStore.getState().newTabSession(tabId!, {});
-            }
-          }
-
-          setTimeout(() => {
-            if (state.current?.ready && !state.current.movedAway)
-              commands.focus(tabId!);
-          });
-        } else {
-          if (!event.item) {
-            overlay(false);
-            return;
-          }
-
-          const item = event.item;
-
-          const currentTab = useTabStore
-            .getState()
-            .getTab(useTabStore.getState().currentTab as string);
-
-          // If note is already open in a tab, focus that tab.
-          if (useTabStore.getState().hasTabForNote(item.id) && !event.newTab) {
-            const tabId = useTabStore.getState().getTabForNote(item.id);
-
-            if (
-              currentTab?.session?.noteId !== item.id &&
-              tabId !== useTabStore.getState().currentTab
-            ) {
-              useTabStore.getState().focusTab(tabId as string);
-              return;
-            }
-          }
-
-          const isLockedNote = await db.vaults.itemExists(
-            event.item as ItemReference
-          );
-
-          const tabLocked =
-            isLockedNote && !(event.item as NoteWithContent).content;
-
-          const tabId = event.tabId
-            ? event.tabId
-            : useTabStore.getState().currentTab;
-
-          // Check if tab needs to be refreshed.
-          if (!event.newTab) {
-            if (
-              !event.refresh &&
-              tabId &&
-              event.item.id === useTabStore.getState().getNoteIdForTab(tabId) &&
-              !localTabState.current?.needsRefresh(
-                tabId,
-                isLockedNote,
-                item.readonly
-              )
-            ) {
-              commands.setLoading(false, tabId);
-              return;
+            if (event.presistTab) {
+              // Open note in new tab.
+              useTabStore.getState().newTab({
+                readonly: event.item.readonly || readonly,
+                locked: tabLocked,
+                noteLocked: isLockedNote,
+                noteId: event.item.id,
+                previewTab: false
+              });
             } else {
-              localTabState.current?.setEditTime(
-                item.id,
-                localTabState.current?.noteEditedTime[item.id] ||
-                  item.dateEdited
-              );
-              localTabState.current?.set(tabId!, {
-                editedAt:
-                  localTabState.current?.noteEditedTime[item.id] ||
-                  item.dateEdited
+              // Otherwise we focus the preview tab or create one to open the note in.
+              useTabStore.getState().focusPreviewTab(event.item.id, {
+                readonly: event.item.readonly || readonly,
+                locked: tabLocked,
+                noteLocked: isLockedNote
               });
             }
           }
+        } else {
+          if (lastTabFocused.current !== event.tabId) {
+            useTabStore.getState().focusTab(event.tabId);
+          }
+        }
 
+        const tabId = event.tabId || useTabStore.getState().currentTab;
+        if (lastTabFocused.current !== tabId) {
+          // if ((await waitForEvent(eEditorTabFocused, 1000)) !== tabId) {
+          //
+          //   return;
+          // }
           currentLoadingNoteId.current = item.id;
 
-          // Show loading overlay if note is not already loaded.
-          if (
-            tabId &&
-            (event.item?.id !== useTabStore.getState().getNoteIdForTab(tabId) ||
-              !currentContents.current[event.item.id]?.data)
-          ) {
-            await commands.setLoading(true, tabId);
-          }
-
-          const session: Partial<TabSessionItem> = event.session || {
-            noteId: event.item.id
-          };
-
-          session.noteLocked = isLockedNote;
-          session.locked = tabLocked;
-          session.readonly = item.readonly;
-
-          const tab = useTabStore.getState().getTab(tabId!);
-
-          if (
-            useTabStore.getState().tabs.length === 0 ||
-            event.newTab ||
-            (currentTab?.pinned &&
-              event.item.id !== currentTab?.session?.noteId)
-          ) {
-            useTabStore.getState().newTab({
-              session: session
-            });
-            return;
-          } else {
-            // A new session is created if the note is changed.
-            // If the note is already opened, the session is updated.
-            if (
-              !tab?.session ||
-              (event.item.id !== tab?.session?.noteId && tab?.session?.noteId)
-            ) {
-              useTabStore.getState().newTabSession(tabId!, session);
-            } else {
-              useTabStore.getState().updateTab(tabId!, {
-                session: session
-              });
-            }
-          }
-
-          if (lastTabFocused.current !== tabId) return;
-
-          if (tabBarRef.current?.page() === 2) {
-            state.current.movedAway = false;
-          }
-
-          state.current.currentlyEditing = true;
-          if (!tabLocked) {
-            await loadContent(item);
-          } else {
-            commands.focus(tabId!);
-          }
-
-          lastContentChangeTime.current[item.id] = item.dateEdited;
-          currentNotes.current[item.id] = item;
-
-          if (!currentNotes.current[item.id]) return;
-
-          editorSessionHistory.newSession(item.id);
-
-          await commands.setStatus(
-            getFormattedDate(item.dateEdited, "date-time"),
-            "Saved",
-            tabId!
-          );
-          await postMessage(NativeEvents.title, item.title, tabId);
-          overlay(false);
-
-          await postMessage(
-            NativeEvents.html,
-            {
-              data: currentContents.current[item.id]?.data || "",
-              scrollTop: tab?.session?.scrollTop,
-              selection: tab?.session?.selection
-            },
-            tabId,
-            10000
-          );
-
-          setTimeout(() => {
-            if (blockIdRef.current) {
-              commands.scrollIntoViewById(blockIdRef.current);
-              blockIdRef.current = undefined;
-            }
-          }, 300);
-
-          await commands.setTags(item);
-          commands.setSettings();
-          setTimeout(() => {
-            if (currentLoadingNoteId.current === event.item?.id) {
-              currentLoadingNoteId.current = undefined;
-            }
-          }, 300);
+          return;
         }
-        postMessage(NativeEvents.theme, theme);
-      });
+
+        state.current.movedAway = false;
+        state.current.currentlyEditing = true;
+
+        if (!tabLocked) {
+          await loadContent(item);
+        }
+
+        if (
+          currentNotes.current[item.id] &&
+          loadingState.current &&
+          currentContents.current[item.id]?.data &&
+          loadingState.current === currentContents.current[item.id]?.data
+        ) {
+          // If note is already loading, return.
+
+          return;
+        }
+
+        if (!state.current.ready) {
+          currentNotes.current[item.id] = item;
+          return;
+        }
+
+        lastContentChangeTime.current[item.id] = 0;
+        currentLoadingNoteId.current = item.id;
+        currentNotes.current[item.id] = item;
+
+        if (!currentNotes.current[item.id]) return;
+
+        editorSessionHistory.newSession(item.id);
+
+        await commands.setStatus(
+          getFormattedDate(item.dateEdited, "date-time"),
+          strings.saved(),
+          tabId
+        );
+
+        await postMessage(EditorEvents.title, item.title, tabId);
+        overlay(false);
+        loadingState.current = currentContents.current[item.id]?.data;
+
+        await postMessage(
+          EditorEvents.html,
+          currentContents.current[item.id]?.data || "",
+          tabId,
+          10000
+        );
+
+        setTimeout(() => {
+          if (blockIdRef.current) {
+            commands.scrollIntoViewById(blockIdRef.current);
+            blockIdRef.current = undefined;
+          }
+        }, 300);
+
+        loadingState.current = undefined;
+        await commands.setTags(item);
+        commands.setSettings();
+        setTimeout(() => {
+          if (currentLoadingNoteId.current === event.item?.id) {
+            currentLoadingNoteId.current = undefined;
+          }
+        }, 300);
+      }
+      postMessage(EditorEvents.theme, theme);
     },
     [
       commands,
@@ -710,6 +615,7 @@ export const useEditor = (
       loadContent,
       overlay,
       postMessage,
+      readonly,
       reset,
       theme
     ]
@@ -721,116 +627,96 @@ export const useEditor = (
       isLocal?: boolean
     ) => {
       try {
-        if (SettingsService.get().disableRealtimeSync && !isLocal) return;
-        if (!data) return;
+        await (async () => {
+          if (SettingsService.get().disableRealtimeSync && !isLocal) return;
+          if (!data) return;
 
-        if (isDeleted(data) || isTrashItem(data)) {
-          const tabId = useTabStore.getState().getTabForNote(data.id);
-          if (tabId !== undefined) {
-            await commands.clearContent(tabId);
-            useTabStore.getState().removeTab(tabId);
+          if (isDeleted(data) || isTrashItem(data)) {
+            const tabId = useTabStore.getState().getTabForNote(data.id);
+            if (tabId !== undefined) {
+              await commands.clearContent(tabId);
+              useTabStore.getState().removeTab(tabId);
+            }
+            return;
           }
-          return;
-        }
 
-        const noteId =
-          (data as ContentItem).type === "tiptap"
-            ? (data as ContentItem).noteId
-            : data.id;
+          const noteId =
+            (data as ContentItem).type === "tiptap"
+              ? (data as ContentItem).noteId
+              : data.id;
 
-        const note = data.type === "note" ? data : await db.notes?.note(noteId);
+          if (!useTabStore.getState().hasTabForNote(noteId)) return;
+          const tabId = useTabStore.getState().getTabForNote(noteId) as number;
 
-        lock.current = true;
+          const tab = useTabStore.getState().getTab(tabId);
 
-        // Handle this case where note was locked on another device and synced.
-        let locked = note
-          ? await db.vaults.itemExists(note as ItemReference)
-          : false;
+          const note =
+            data.type === "note" ? data : await db.notes?.note(noteId);
 
-        if (data.type === "tiptap") {
-          locked = data.locked;
-        }
+          lock.current = true;
 
-        useTabStore.getState().forEachNoteTab(noteId, async (tab) => {
-          const tabId = tab.id;
-
-          let didUnlock = false;
+          // Handle this case where note was locked on another device and synced.
+          const locked = note
+            ? await db.vaults.itemExists(note as ItemReference)
+            : false;
 
           if (note) {
-            if (!locked && tab?.session?.noteLocked) {
-              if (tab?.session?.noteLocked || tab?.session?.locked) {
-                if (useTabStore.getState().currentTab !== tabId) {
-                  localTabState.current?.set(tabId, {
-                    editedAt: 0
+            if (!locked && tab?.noteLocked) {
+              // Note lock removed.
+              if (tab.locked) {
+                if (useTabStore.getState().currentTab === tabId) {
+                  eSendEvent(eOnLoadNote, {
+                    item: note,
+                    forced: true
                   });
-                }
-
-                didUnlock = true;
-                useTabStore.getState().updateTab(tabId, {
-                  session: {
+                } else {
+                  useTabStore.getState().updateTab(tabId, {
                     locked: false,
                     noteLocked: false
-                  }
-                });
-              }
-            } else if (!tab?.session?.noteLocked && locked) {
-              useTabStore.getState().updateTab(tabId, {
-                session: {
-                  locked: true,
-                  noteLocked: true
+                  });
+                  commands.setLoading(true, tabId);
                 }
+              }
+            } else if (!tab?.noteLocked && locked) {
+              // Note lock added.
+              useTabStore.getState().updateTab(tabId, {
+                locked: true,
+                noteLocked: true
               });
-              commands.clearContent(tabId);
               if (useTabStore.getState().currentTab !== tabId) {
+                commands.clearContent(tabId);
                 commands.setLoading(true, tabId);
               }
-              localTabState.current?.set(tabId, {
-                editedAt: 0
-              });
             }
 
-            if (
-              currentNotes.current[noteId]?.title !== note.title ||
-              didUnlock
-            ) {
-              postMessage(NativeEvents.title, note.title, tabId);
+            if (currentNotes.current[noteId]?.title !== note.title) {
+              postMessage(EditorEvents.title, note.title, tabId);
             }
             commands.setTags(note);
-            if (
-              currentNotes.current[noteId]?.dateEdited !== note.dateEdited ||
-              didUnlock
-            ) {
+            if (currentNotes.current[noteId]?.dateEdited !== note.dateEdited) {
               commands.setStatus(
                 getFormattedDate(note.dateEdited, "date-time"),
                 strings.saved(),
-                tabId as string
+                tabId as number
               );
             }
-            if (tab.session?.readonly !== note.readonly || didUnlock) {
-              useTabStore.getState().updateTab(tabId, {
-                session: {
-                  readonly: note.readonly
-                }
-              });
-            }
+
+            useTabStore.getState().updateTab(tabId, {
+              readonly: note.readonly
+            });
           }
 
           if (data.type === "tiptap" && note && !isLocal) {
-            if (
-              lastContentChangeTime.current[noteId] >= data.dateModified &&
-              !didUnlock
-            ) {
+            if (lastContentChangeTime.current[noteId] >= data.dateModified) {
               return;
             }
 
             if (locked && isEncryptedContent(data)) {
               const decryptedContent = await db.vault?.decryptContent(data);
               if (!decryptedContent) {
-                useTabStore.getState().updateTab(tab.id, {
-                  session: {
-                    locked: true,
-                    noteLocked: true
-                  }
+                useTabStore.getState().updateTab(tabId, {
+                  locked: true,
+                  noteLocked: true
                 });
                 if (useTabStore.getState().currentTab !== tabId) {
                   commands.clearContent(tabId);
@@ -838,43 +724,26 @@ export const useEditor = (
                 }
               } else {
                 await postMessage(
-                  NativeEvents.updatehtml,
-                  {
-                    data: decryptedContent.data,
-                    selection: tab.session?.selection,
-                    scrollTop: tab.session?.scrollTop
-                  },
+                  EditorEvents.updatehtml,
+                  decryptedContent.data,
                   tabId
                 );
                 currentContents.current[note.id] = decryptedContent;
               }
             } else {
               const _nextContent = data.data;
-              if (
-                _nextContent === currentContents.current[note.id]?.data &&
-                !didUnlock
-              ) {
+              if (_nextContent === currentContents.current[note.id]?.data) {
                 return;
               }
-
               lastContentChangeTime.current[note.id] = note.dateEdited;
-              console.log(tab.session?.selection);
-              await postMessage(
-                NativeEvents.updatehtml,
-                {
-                  data: _nextContent,
-                  selection: tab.session?.selection,
-                  scrollTop: tab.session?.scrollTop
-                },
-                tabId
-              );
+              await postMessage(EditorEvents.updatehtml, _nextContent, tabId);
               if (!isEncryptedContent(data)) {
                 currentContents.current[note.id] =
                   data as UnencryptedContentItem;
               }
             }
           }
-        });
+        })();
       } catch (e) {
         DatabaseLogger.error(e as Error, "Error when applying sync changes");
       } finally {
@@ -910,7 +779,7 @@ export const useEditor = (
       content?: string;
       type: string;
       ignoreEdit: boolean;
-      tabId: string;
+      tabId: number;
       pendingChanges?: boolean;
     }) => {
       DatabaseLogger.log(
@@ -939,13 +808,9 @@ export const useEditor = (
 
       if (noteId) {
         lastContentChangeTime.current[noteId] = Date.now();
-        localTabState.current?.setEditTime(noteId, Date.now());
-        localTabState?.current?.set(tabId, {
-          editedAt: Date.now()
-        });
       }
 
-      if (type === EditorEvents.content && noteId) {
+      if (type === EventTypes.content && noteId) {
         currentContents.current[noteId as string] = {
           data: content,
           type: "tiptap",
@@ -995,9 +860,7 @@ export const useEditor = (
     if (!appState) return;
     state.current.isRestoringState = true;
     state.current.currentlyEditing = true;
-    if (tabBarRef.current?.page() === 2) {
-      state.current.movedAway = false;
-    }
+    state.current.movedAway = false;
 
     if (!state.current.editorStateRestored) {
       state.current.isRestoringState = true;
@@ -1028,12 +891,9 @@ export const useEditor = (
       !(await isEditorLoaded(
         editorRef,
         sessionIdRef.current,
-        useTabStore.getState().currentTab!
+        useTabStore.getState().currentTab
       ))
     ) {
-      localTabState.current?.set(useTabStore.getState().currentTab!, {
-        editedAt: 0
-      });
       eSendEvent(eEditorReset, "onReady");
       return false;
     } else {
@@ -1044,61 +904,44 @@ export const useEditor = (
   }, [isDefaultEditor, restoreEditorState]);
 
   const onLoad = useCallback(async () => {
-    const isAppLoading = useSettingStore.getState().isAppLoading;
-    if (isAppLoading) {
-      const sub = useSettingStore.subscribe((state) => {
-        if (!state.isAppLoading) {
-          sub();
-          onLoad();
-        }
-      });
-      return;
-    }
-
     setTimeout(() => {
-      postMessage(NativeEvents.theme, theme);
+      postMessage(EditorEvents.theme, theme);
     });
     commands.setInsets(
       isDefaultEditor ? insets : { top: 0, left: 0, right: 0, bottom: 0 }
     );
     await commands.setSettings();
 
-    localTabState.current?.set(useTabStore.getState().currentTab!, {
-      editedAt: 0
-    });
-
     if (!state.current.ready) {
       state.current.ready = true;
     }
 
-    if (!state.current?.initialLoadCalled) {
-      const url = await Linking.getInitialURL();
-      let noteId = url && new URL(url).searchParams.get("id");
-      if (noteId) {
-        const note = await db.notes?.note(noteId);
+    const appState = getAppState();
+    if (appState?.noteId) {
+      const note = await db.notes?.note(appState.noteId);
+      if (note) {
+        loadNote({
+          item: note
+        });
+      }
+    } else {
+      const noteId = useTabStore.getState().getCurrentNoteId();
+      if (!noteId) {
+        loadNote({ newNote: true });
+        if (tabBarRef.current?.page() === 1) {
+          state.current.currentlyEditing = false;
+        }
+      } else if (state.current?.initialLoadCalled) {
+        const note = currentNotes.current[noteId];
         if (note) {
           loadNote({
             item: note
           });
         }
-        tabBarRef.current?.goToPage(1);
-      } else {
-        noteId = useTabStore.getState().getCurrentNoteId() || null;
-        if (!noteId) {
-          loadNote({ newNote: true });
-          if (tabBarRef.current?.page() === 1) {
-            state.current.currentlyEditing = false;
-          }
-        } else {
-          const note = await db.notes.note(noteId);
-          if (note) {
-            loadNote({
-              item: note
-            });
-          }
-        }
       }
-      state.current.initialLoadCalled = true;
+      if (!state.current?.initialLoadCalled) {
+        state.current.initialLoadCalled = true;
+      }
       overlay(false);
     }
   }, [

apps/mobile/app/screens/editor/tiptap/use-tab-store.ts

@@ -16,27 +16,18 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-import {
-  TabHistory as TabHistoryType,
-  TabSessionHistory
-} from "@notesnook/common";
-import { getId } from "@notesnook/core";
-import { MMKVLoader } from "react-native-mmkv-storage";
 import create from "zustand";
 import { persist, StateStorage } from "zustand/middleware";
-import { db } from "../../../common/database";
 import { MMKV } from "../../../common/database/mmkv";
-import { eSendEvent } from "../../../services/event-manager";
-import { eOnLoadNote } from "../../../utils/events";
 import { editorController } from "./utils";
 
-class TabHistory {
-  history: string[];
+class History {
+  history: number[];
   constructor() {
-    this.history = [];
+    this.history = [0];
   }
 
-  add(item: string) {
+  add(item: number) {
     const index = this.history.findIndex((id) => item === id);
     if (index !== -1) {
       // Item already exists, move it to the top
@@ -45,19 +36,19 @@ class TabHistory {
     this.history.unshift(item); // Add item to the beginning of the array
 
     useTabStore.setState({
-      historyNew: this.history.slice()
+      tabHistory: this.history.slice()
     });
     return true; // Item added successfully
   }
 
-  remove(id: string) {
+  remove(id: number) {
     const index = this.history.findIndex((item) => item === id);
     if (index >= -1 && index < this.history.length) {
       const removedItem = this.history.splice(index, 1)[0];
       return removedItem;
     }
     useTabStore.setState({
-      historyNew: this.history.slice()
+      tabHistory: this.history.slice()
     });
     return null; // Invalid index
   }
@@ -68,7 +59,7 @@ class TabHistory {
       return restoredItem;
     }
     useTabStore.setState({
-      historyNew: this.history.slice()
+      tabHistory: this.history.slice()
     });
     return null; // History is empty
   }
@@ -78,365 +69,147 @@ class TabHistory {
   }
 }
 
-export type TabSessionItem = {
-  id: string;
-  noteId?: string;
-  scrollTop?: number;
-  selection?: { to: number; from: number };
-  noteLocked?: boolean;
-  locked?: boolean;
-  readonly?: boolean;
-};
-
-const TabSessionStorageKV = new MMKVLoader()
-  .withInstanceID("tab-session-storage")
-  .disableIndexing()
-  .initialize();
-
-class TabSessionStorage {
-  static storage: typeof TabSessionStorageKV = TabSessionStorageKV;
-
-  static get(id: string): TabSessionItem | null {
-    if (!id) return null;
-    return TabSessionStorage.storage.getMap(id);
-  }
-
-  static set(id: string, session: TabSessionItem): void {
-    if (!id) return;
-    TabSessionStorage.storage.setMap(id, session);
-  }
-
-  static update(id: string, session: Partial<TabSessionItem>) {
-    const currentSession = TabSessionStorage.get(id);
-    const newSession = {
-      ...currentSession,
-      ...session,
-      id: currentSession?.id || session.id || id
-    };
-
-    TabSessionStorage.set(id, newSession as TabSessionItem);
-    return newSession;
-  }
-
-  static remove(id: string) {
-    if (!id) return;
-    TabSessionStorageKV.removeItem(id);
-  }
-}
-
-export function syncTabs(
-  type: "tabs" | "history" | "biometry" | "all" = "all"
-) {
-  const data: Partial<TabStore> = {};
-  if (type === "tabs" || type === "all") {
-    data.tabs = useTabStore.getState().tabs;
-    data.currentTab = useTabStore.getState().currentTab;
-  }
-  if (type === "history" || type === "all") {
-    data.canGoBack = useTabStore.getState().canGoBack;
-    data.canGoForward = useTabStore.getState().canGoForward;
-    data.sessionId = useTabStore.getState().sessionId;
-  }
-
-  if (type === "biometry" || type === "all") {
-    data.biometryAvailable = useTabStore.getState().biometryAvailable;
-    data.biometryEnrolled = useTabStore.getState().biometryEnrolled;
-  }
-
-  editorController.current?.commands.doAsync(`
-    globalThis.tabStore?.setState(${JSON.stringify(data)});
-`);
-}
-export const tabSessionHistory = new TabSessionHistory({
-  get() {
-    return useTabStore.getState();
-  },
-  set(state) {
-    useTabStore.setState({
-      ...state
-    });
-  }
-});
-
 export type TabItem = {
-  id: string;
+  id: number;
+  noteId?: string;
+  previewTab?: boolean;
+  readonly?: boolean;
+  locked?: boolean;
+  noteLocked?: boolean;
   pinned?: boolean;
-  needsRefresh?: boolean;
-  session?: Partial<TabSessionItem>;
 };
 
-const history = new TabHistory();
+const history = new History();
 
 export type TabStore = {
   tabs: TabItem[];
-  currentTab: string;
-  updateTab: (id: string, options: Omit<Partial<TabItem>, "id">) => void;
+  currentTab: number;
+  updateTab: (id: number, options: Omit<Partial<TabItem>, "id">) => void;
   focusPreviewTab: (
     noteId: string,
     options: Omit<Partial<TabItem>, "id">
   ) => void;
-  removeTab: (index: string) => void;
+  removeTab: (index: number) => void;
   moveTab: (index: number, toIndex: number) => void;
-  newTab: (options?: Omit<Partial<TabItem>, "id">) => string;
-  focusTab: (id: string) => void;
-  getNoteIdForTab: (id: string) => string | undefined;
-  getTabForNote: (noteId: string) => string | undefined;
-  getTabsForNote: (noteId: string) => TabItem[];
-  forEachNoteTab: (noteId: string, cb: (tab: TabItem) => void) => void;
+  newTab: (options?: Omit<Partial<TabItem>, "id">) => void;
+  focusTab: (id: number) => void;
+  getNoteIdForTab: (id: number) => string | undefined;
+  getTabForNote: (noteId: string) => number | undefined;
   hasTabForNote: (noteId: string) => boolean;
   focusEmptyTab: () => void;
   getCurrentNoteId: () => string | undefined;
-  getTab: (tabId: string) => TabItem | undefined;
-  newTabSession: (
-    id: string,
-    options?: Omit<Partial<TabSessionItem>, "id">
-  ) => void;
-  historyNew: string[];
+  getTab: (tabId: number) => TabItem | undefined;
+  tabHistory: number[];
   biometryAvailable?: boolean;
   biometryEnrolled?: boolean;
-  tabSessionHistory: TabHistoryType;
-  goBack(): void;
-  goForward(): void;
-  loadSession: (id: string) => Promise<boolean>;
-  canGoBack?: boolean;
-  canGoForward?: boolean;
-  sessionId?: string;
 };
 
-const DEFAULT_TABS = {
-  tabs: [
-    {
-      id: "679da59a3924d4bd56d16d3f",
-      session: {
-        id: "679da5a5667a16db2353a062"
-      }
-    }
-  ],
-  tabSessionHistory: {
-    "679da59a3924d4bd56d16d3f": {
-      backStack: ["679da5a5667a16db2353a062"],
-      forwardStack: [] as string[]
-    }
-  } as TabHistoryType,
-  historyNew: ["679da59a3924d4bd56d16d3f"],
-  currentTab: "679da59a3924d4bd56d16d3f"
-} as TabStore;
+function getId(id: number, tabs: TabItem[]): number {
+  const exists = tabs.find((t) => t.id === id);
+  if (exists) {
+    return getId(id + 1, tabs);
+  }
+  return id;
+}
 
-export function resetTabStore() {
-  useTabStore.setState({
-    ...DEFAULT_TABS
-  });
-  TabSessionStorage.storage.clearStore();
+export function syncTabs() {
+  editorController.current?.commands.doAsync(`
+    globalThis.tabStore?.setState({
+      tabs: ${JSON.stringify(useTabStore.getState().tabs)},
+      currentTab: ${useTabStore.getState().currentTab},
+      biometryAvailable: ${useTabStore.getState().biometryAvailable},
+      biometryEnrolled: ${useTabStore.getState().biometryEnrolled}
+    });
+`);
 }
 
 export const useTabStore = create<TabStore>(
   persist(
     (set, get) => ({
-      ...DEFAULT_TABS,
-      newTabSession: (
-        _id?: string,
-        options?: Omit<Partial<TabSessionItem>, "id">
-      ) => {
-        const tabId = _id || (get().currentTab as string);
-
-        const sessionHistory = get().tabSessionHistory[tabId];
-
-        let oldSessionId: string | undefined = undefined;
-        if (sessionHistory) {
-          const allSessions = sessionHistory.backStack.concat(
-            sessionHistory.forwardStack
-          );
-          allSessions.forEach((id) => {
-            if (TabSessionStorage.get(id)?.noteId === options?.noteId) {
-              oldSessionId = id;
-            }
-          });
+      tabs: [
+        {
+          id: 0
         }
-
-        const sessionId =
-          oldSessionId &&
-          tabSessionHistory.currentSessionId(tabId) === oldSessionId
-            ? oldSessionId
-            : tabSessionHistory.add(tabId, oldSessionId);
-
-        let session: Partial<TabSessionItem>;
-
-        if (!oldSessionId) {
-          session = {
-            id: sessionId,
-            ...options
-          };
-          TabSessionStorage.set(sessionId, session as TabSessionItem);
-        } else {
-          session = {
-            id: sessionId,
-            ...TabSessionStorage.get(oldSessionId),
-            ...options
-          };
-        }
-
-        const index = get().tabs.findIndex((t) => t.id === tabId);
-        if (index == -1) return;
-        const tabs = [...get().tabs];
-        tabs[index] = {
-          ...tabs[index],
-          session: session
-        } as TabItem;
-
-        set({
-          tabs: tabs
-        });
-        syncTabs();
-      },
-      updateTab: (id: string, options: Omit<Partial<TabItem>, "id">) => {
+      ],
+      tabHistory: [0],
+      history: new History(),
+      currentTab: 0,
+      updateTab: (id: number, options: Omit<Partial<TabItem>, "id">) => {
         if (!options) return;
         const index = get().tabs.findIndex((t) => t.id === id);
         if (index == -1) return;
         const tabs = [...get().tabs];
-        const sessionId =
-          options.session?.id || (tabs[index].session?.id as string);
-
-        const updatedSession = !options.session
-          ? tabs[index].session
-          : TabSessionStorage.update(sessionId, options.session);
-
         tabs[index] = {
           ...tabs[index],
-          ...options,
-          session: updatedSession
-        } as TabItem;
+          ...options
+        };
 
         set({
           tabs: tabs
         });
         syncTabs();
       },
-      goBack: async () => {
-        const currentTab = get().currentTab;
-        if (!currentTab) return;
-        if (!tabSessionHistory.canGoBack(currentTab)) return;
-
-        const id = tabSessionHistory.back(currentTab) as string;
-        const sessionLoaded = await get().loadSession(id);
-
-        if (!sessionLoaded) {
-          const canGoBack = tabSessionHistory.canGoBack(currentTab);
-          if (!canGoBack) {
-            tabSessionHistory.forward(currentTab);
-            syncTabs();
-          } else {
-            get().goBack();
-            tabSessionHistory.remove(currentTab, id);
-            TabSessionStorage.remove(id);
-            return;
-          }
-        } else {
-          syncTabs();
-        }
-      },
-      goForward: async () => {
-        const currentTab = get().currentTab;
-        if (!currentTab) return;
-
-        if (!tabSessionHistory.canGoForward(currentTab)) return;
-        const id = tabSessionHistory.forward(currentTab) as string;
-        if (!(await get().loadSession(id))) {
-          const canGoForward = tabSessionHistory.canGoForward(currentTab);
-          if (!canGoForward) {
-            tabSessionHistory.back(currentTab);
-            syncTabs();
-          } else {
-            get().goForward();
-            tabSessionHistory.remove(currentTab, id);
-            TabSessionStorage.remove(id);
-            return;
-          }
-        } else {
-          syncTabs();
-        }
-      },
-      loadSession: async (id: string) => {
-        const session = TabSessionStorage.get(id);
-        if (!session) return false;
-
-        const note = session?.noteId
-          ? await db.notes.note(session?.noteId)
-          : undefined;
-
-        if (note) {
-          const isLocked = await db.vaults.itemExists(note);
-          session.noteLocked = isLocked;
-          session.locked = isLocked;
-
-          session.readonly = note.readonly;
-        } else if (session.noteId) {
-          console.log("Failed to load session...");
-          return false;
-        }
-
-        eSendEvent(eOnLoadNote, {
-          item: note,
-          newNote: !note,
-          tabId: get().currentTab,
-          session: session
-        });
-
-        return true;
-      },
       focusPreviewTab: (
         noteId: string,
         options: Omit<Partial<TabItem>, "id" | "noteId">
-      ) => {},
+      ) => {
+        const index = get().tabs.findIndex((t) => t.previewTab);
+        if (index === -1)
+          return get().newTab({
+            noteId,
+            previewTab: true,
+            ...options
+          });
+        const tabs = [...get().tabs];
+        tabs[index] = {
+          ...tabs[index],
+          ...options,
+          previewTab: true,
+          noteId: noteId
+        };
 
-      removeTab: (id: string) => {
+        set({
+          tabs: tabs
+        });
+        get().focusTab(tabs[index].id);
+      },
+      removeTab: (id: number) => {
         const index = get().tabs.findIndex((t) => t.id === id);
+
         if (index > -1) {
           const isFocused = id === get().currentTab;
           const nextTabs = get().tabs.slice();
           nextTabs.splice(index, 1);
           history.remove(id);
-
-          const tabSessions = tabSessionHistory.getTabHistory(id);
-          tabSessions.back.forEach((id) => TabSessionStorage.remove(id));
-          tabSessions.forward.forEach((id) => TabSessionStorage.remove(id));
-          tabSessionHistory.clearStackForTab(id);
-
           if (nextTabs.length === 0) {
-            const id = getId();
-            set({
-              tabs: [{ id: id }]
+            nextTabs.push({
+              id: 0
             });
-            get().newTabSession(id);
-            get().focusTab(id);
-          } else {
-            set({
-              tabs: nextTabs
-            });
-            if (isFocused) {
-              const lastTab = history.restoreLast();
-              if (lastTab) get().focusTab(lastTab);
-            }
           }
-          syncTabs();
+          set({
+            tabs: nextTabs
+          });
+          get().focusTab(
+            isFocused ? history.restoreLast() || 0 : get().currentTab
+          );
         }
       },
       newTab: (options) => {
-        const id = getId();
+        const id = getId(get().tabs.length, get().tabs);
+        const nextTabs = [
+          ...get().tabs,
+          {
+            id: id,
+            ...options
+          }
+        ];
         set({
-          tabs: [
-            ...get().tabs,
-            {
-              id: id,
-              ...options
-            }
-          ]
+          tabs: nextTabs
         });
-        get().newTabSession(id, options?.session || {});
         get().focusTab(id);
-        return id;
       },
       focusEmptyTab: () => {
-        const index = get().tabs.findIndex((t) => !t.session?.noteId);
+        const index = get().tabs.findIndex((t) => !t.noteId);
         if (index === -1) return get().newTab();
 
         get().focusTab(get().tabs[index].id);
@@ -450,46 +223,37 @@ export const useTabStore = create<TabStore>(
         syncTabs();
       },
 
-      focusTab: (id: string) => {
+      focusTab: (id: number) => {
         history.add(id);
         set({
-          currentTab: id,
-          canGoBack: tabSessionHistory.canGoBack(id),
-          canGoForward: tabSessionHistory.canGoForward(id),
-          sessionId: tabSessionHistory.currentSessionId(id)
+          currentTab: id
         });
         syncTabs();
       },
-      getNoteIdForTab: (id: string) => {
-        return get().tabs.find((t) => t.id === id)?.session?.noteId;
+      getNoteIdForTab: (id: number) => {
+        return get().tabs.find((t) => t.id === id)?.noteId;
       },
       hasTabForNote: (noteId: string) => {
-        return !!get().tabs.find((t) => t.session?.noteId === noteId);
+        return (
+          typeof get().tabs.find((t) => t.noteId === noteId)?.id === "number"
+        );
       },
       getTabForNote: (noteId: string) => {
-        return get().tabs.find((t) => t.session?.noteId === noteId)?.id;
-      },
-      getTabsForNote(noteId: string) {
-        return get().tabs.filter((t) => t.session?.noteId === noteId);
-      },
-      forEachNoteTab: (noteId: string, cb: (tab: TabItem) => void) => {
-        const tabs = get().tabs.filter((t) => t.session?.noteId === noteId);
-        tabs.forEach(cb);
+        return get().tabs.find((t) => t.noteId === noteId)?.id;
       },
       getCurrentNoteId: () => {
-        return get().tabs.find((t) => t.id === get().currentTab)?.session
-          ?.noteId;
+        return get().tabs.find((t) => t.id === get().currentTab)?.noteId;
       },
       getTab: (tabId) => {
         return get().tabs.find((t) => t.id === tabId);
       }
     }),
     {
-      name: "tabs-storage-v5",
+      name: "tabs-storage",
       getStorage: () => MMKV as unknown as StateStorage,
       onRehydrateStorage: () => {
         return (state) => {
-          history.history = state?.historyNew || [];
+          history.history = state?.tabHistory.slice() || [];
         };
       }
     }

apps/mobile/app/screens/editor/tiptap/utils.ts

@@ -31,8 +31,6 @@ import { eOnLoadNote } from "../../../utils/events";
 import { NotesnookModule } from "../../../utils/notesnook-module";
 import { AppState, EditorState, useEditorType } from "./types";
 import { useTabStore } from "./use-tab-store";
-import { NativeEvents } from "@notesnook/editor-mobile/src/utils/native-events";
-
 export const textInput = createRef<TextInput>();
 export const editorController =
   createRef<useEditorType>() as MutableRefObject<useEditorType>;
@@ -48,6 +46,19 @@ export function editorState() {
   return editorController.current?.state.current || defaultState;
 }
 
+export const EditorEvents = {
+  html: "native:html",
+  updatehtml: "native:updatehtml",
+  title: "native:title",
+  theme: "native:theme",
+  titleplaceholder: "native:titleplaceholder",
+  logger: "native:logger",
+  status: "native:status",
+  keyboardShown: "native:keyboardShown",
+  attachmentData: "native:attachment-data",
+  resolve: "native:resolve"
+};
+
 export function randId(prefix: string) {
   return Math.random()
     .toString(36)
@@ -61,15 +72,15 @@ export function makeSessionId(id?: string) {
 export async function isEditorLoaded(
   ref: RefObject<WebView>,
   sessionId: string,
-  tabId: string
+  tabId: number
 ) {
-  return await post(ref, sessionId, tabId, NativeEvents.status);
+  return await post(ref, sessionId, tabId, EditorEvents.status);
 }
 
 export async function post<T>(
   ref: RefObject<WebView>,
   sessionId: string,
-  tabId: string,
+  tabId: number,
   type: string,
   value: T | null = null,
   waitFor = 300
@@ -174,7 +185,7 @@ export async function openInternalLink(url: string) {
   if (!data?.id) return false;
   if (
     data.id ===
-    useTabStore.getState().getNoteIdForTab(useTabStore.getState().currentTab!)
+    useTabStore.getState().getNoteIdForTab(useTabStore.getState().currentTab)
   ) {
     if (data.params?.blockId) {
       setTimeout(() => {

apps/mobile/app/screens/settings/restore-backup/index.tsx

@@ -148,7 +148,7 @@ const restoreBackup = async (options: {
 
       let count = 0;
       await db.transaction(async () => {
-        let passwordOrKey: PasswordOrKey | undefined = undefined;
+        let passwordOrKey: PasswordOrKey;
         for (const path of extractedBackupFiles) {
           if (path === ".nnbackup" || path === "attachments") continue;
 
@@ -166,7 +166,7 @@ const restoreBackup = async (options: {
 
           passwordOrKey = !isEncryptedBackup
             ? ({} as PasswordOrKey)
-            : passwordOrKey || (await withPassword());
+            : await withPassword();
 
           if (
             isEncryptedBackup &&

apps/mobile/app/screens/settings/section-item.tsx

@@ -23,7 +23,7 @@ import {
   StackActions,
   useNavigation
 } from "@react-navigation/native";
-import React, { useEffect, useRef, useState } from "react";
+import React, { useRef, useState } from "react";
 import { ActivityIndicator, TextInput, View } from "react-native";
 import Icon from "react-native-vector-icons/MaterialCommunityIcons";
 import ToggleSwitch from "toggle-switch-react-native";
@@ -41,10 +41,7 @@ import { RouteParams, SettingSection } from "./types";
 
 const _SectionItem = ({ item }: { item: SettingSection }) => {
   const { colors } = useThemeColors();
-  const [settings, itemProperty] = useSettingStore((state) => [
-    state.settings,
-    item.property ? state.settings[item.property] : null
-  ]);
+  const settings = useSettingStore((state) => state.settings);
   const navigation = useNavigation<NavigationProp<RouteParams>>();
   const current = item.useHook && item.useHook(item);
   const [isHidden, setIsHidden] = useState(
@@ -106,11 +103,6 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
     }
   };
 
-  useEffect(() => {
-    setIsHidden(item.hidden && item.hidden(item.property || current));
-    setIsDisabled(item.disabled && item.disabled(item.property || current));
-  }, [current, item, itemProperty]);
-
   return isHidden ? null : (
     <Pressable
       disabled={item.type === "component" || isDisabled}

apps/mobile/app/screens/settings/settings-data.tsx

@@ -451,7 +451,7 @@ export const settingsGroups: SettingSection[] = [
                             "local",
                             "partial"
                           );
-                          if (result?.error) throw result.error as Error;
+                          if (result.error) throw result.error as Error;
                         } catch (e) {
                           DatabaseLogger.error(e);
                           const error = e;

apps/mobile/app/services/backup.ts

@@ -30,16 +30,11 @@ import { DatabaseLogger, db } from "../common/database";
 import filesystem, { FileStorage } from "../common/filesystem";
 import { cacheDir, copyFileAsync } from "../common/filesystem/utils";
 import { presentDialog } from "../components/dialog/functions";
-import {
-  endProgress,
-  startProgress,
-  updateProgress
-} from "../components/dialogs/progress";
+import { endProgress, updateProgress } from "../components/dialogs/progress";
 import { eCloseSheet } from "../utils/events";
 import { sleep } from "../utils/time";
 import { ToastManager, eSendEvent, presentSheet } from "./event-manager";
 import SettingsService from "./settings";
-import { getCachePathForFile } from "../common/filesystem/io";
 
 const MS_DAY = 86400000;
 const MS_WEEK = MS_DAY * 7;
@@ -160,7 +155,6 @@ async function updateNextBackupTime(type: "full" | "partial") {
     [type === "full" ? "lastFullBackupDate" : "lastBackupDate"]: Date.now()
   });
 }
-let backupRunning = false;
 /**
  * @param {boolean=} progress
  * @param {string=} context
@@ -170,23 +164,7 @@ async function run(
   progress = false,
   context?: string,
   backupType: "full" | "partial" = "partial"
-): Promise<{
-  path?: string;
-  error?: Error;
-  report?: boolean;
-}> {
-  if (backupRunning) {
-    if (progress) {
-      startProgress({
-        title: strings.backingUpData(backupType),
-        paragraph: strings.backupDataDesc(),
-        progress: "Backup in progress...",
-        canHideProgress: true
-      });
-    }
-    return {};
-  }
-  backupRunning = true;
+) {
   const androidBackupDirectory = (await checkBackupDirExists(
     false,
     context
@@ -214,11 +192,10 @@ async function run(
   );
 
   if (progress) {
-    startProgress({
+    presentSheet({
       title: strings.backingUpData(backupType),
       paragraph: strings.backupDataDesc(),
-      progress: "Preparing backup...",
-      canHideProgress: true
+      progress: true
     });
   }
 
@@ -240,7 +217,6 @@ async function run(
 
   try {
     const user = await db.user.getUser();
-    DatabaseLogger.info(`Backup started: ${backupType}`);
     for await (const file of db.backup.export({
       type: "mobile",
       encrypt: SettingsService.get().encryptedBackup && !!user,
@@ -260,28 +236,20 @@ async function run(
           progress: `Saving attachments in backup... ${file.hash}`
         });
         if (await FileStorage.exists(file.hash)) {
-          await RNFetchBlob.fs
-            .cp(
-              await getCachePathForFile(file.hash),
-              `${attachmentsDir}/${file.hash}`
-            )
-            .catch((e) =>
-              DatabaseLogger.error(e, "Error saving attachment to backup file")
-            );
+          await RNFetchBlob.fs.cp(
+            `${cacheDir}/${file.hash}`,
+            `${attachmentsDir}/${file.hash}`
+          );
         }
       }
     }
 
-    DatabaseLogger.info(`Backup complete: ${backupType}. Creating zip file...`);
-
     updateProgress({
       progress: "Creating backup zip file..."
     });
 
     await zip(zipSourceFolder, zipOutputFile);
 
-    DatabaseLogger.info(`Backup zip file created: ${zipOutputFile}`);
-
     if (Platform.OS === "android") {
       // Move the zip to user selected directory.
       const file = await ScopedStorage.createFile(
@@ -290,17 +258,21 @@ async function run(
         "application/nnbackupz"
       );
 
-      DatabaseLogger.info("Copying backup file to user selected directory...");
-
       await copyFileAsync(`file://${zipOutputFile}`, file.uri);
-      DatabaseLogger.info("Backup saved to user selected directory.");
 
       path = file.uri;
     } else {
       path = zipOutputFile;
     }
 
-    cleanupAfterBackup(zipSourceFolder, zipOutputFile);
+    RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
+      /* empty */
+    });
+    if (Platform.OS === "android") {
+      RNFetchBlob.fs.unlink(zipOutputFile).catch(() => {
+        /* empty */
+      });
+    }
 
     updateNextBackupTime(backupType || "partial");
 
@@ -311,8 +283,6 @@ async function run(
     const canShowCompletionStatus =
       progress && SettingsService.get().showBackupCompleteSheet;
 
-    backupRunning = false;
-
     if (context) {
       return {
         path: path
@@ -330,11 +300,11 @@ async function run(
       type: "success",
       context: "global"
     });
+
     return {
       path: path
     };
   } catch (e) {
-    backupRunning = false;
     ToastManager.error(e as Error, strings.backupFailed(), context || "global");
 
     if (
@@ -345,30 +315,27 @@ async function run(
       return run(progress, context, backupType);
     }
 
-    cleanupAfterBackup(zipSourceFolder, zipOutputFile);
+    RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
+      /* empty */
+    });
+    if (Platform.OS === "android") {
+      RNFetchBlob.fs.unlink(zipOutputFile).catch(() => {
+        /* empty */
+      });
+    }
 
     DatabaseLogger.error(e);
+    await sleep(300);
     if (progress) {
       endProgress();
     }
     return {
-      error: e as Error,
+      error: e,
       report: true
     };
   }
 }
 
-function cleanupAfterBackup(zipSourceFolder: string, zipOutputFile: string) {
-  RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
-    /* empty */
-  });
-  if (Platform.OS === "android") {
-    RNFetchBlob.fs.unlink(zipOutputFile).catch(() => {
-      /* empty */
-    });
-  }
-}
-
 async function checkBackupRequired(
   type: "daily" | "off" | "useroff" | "weekly" | "monthly" | "never",
   lastBackupDateType: "lastBackupDate" | "lastFullBackupDate" = "lastBackupDate"

apps/mobile/app/services/notifications.ts

@@ -43,7 +43,6 @@ import { useRelationStore } from "../stores/use-relation-store";
 import { useReminderStore } from "../stores/use-reminder-store";
 import { useSettingStore } from "../stores/use-setting-store";
 import { useUserStore } from "../stores/use-user-store";
-import { eOnLoadNote } from "../utils/events";
 import { tabBarRef } from "../utils/global-refs";
 import { convertNoteToText } from "../utils/note-to-text";
 import { NotesnookModule } from "../utils/notesnook-module";
@@ -450,10 +449,19 @@ async function loadNote(id: string, jump: boolean) {
     })
   );
 
+  const isLocked = await db.vaults.itemExists({
+    type: "note",
+    id: id
+  });
+
   const tab = useTabStore.getState().getTabForNote(id);
-  if (useTabStore.getState().currentTab !== tab) {
-    eSendEvent(eOnLoadNote, {
-      note: note
+  if (tab !== undefined) {
+    useTabStore.getState().focusTab(tab);
+  } else {
+    useTabStore.getState().focusPreviewTab(id, {
+      noteId: id,
+      readonly: note.readonly,
+      noteLocked: isLocked
     });
   }
 }

apps/mobile/app/services/settings.ts

@@ -45,17 +45,7 @@ function resetSettings() {
     ...defaultSettings,
     introCompleted: true,
     serverUrls: get().serverUrls,
-    backupDirectoryAndroid: get().backupDirectoryAndroid,
-    darkTheme: get().darkTheme,
-    lighTheme: get().lighTheme,
-    useSystemTheme: get().useSystemTheme,
-    colorScheme: get().colorScheme,
-    defaultSnoozeTime: get().defaultSnoozeTime,
-    defaultFontFamily: get().defaultFontFamily,
-    defaultFontSize: get().defaultFontSize,
-    privacyScreen: get().privacyScreen,
-    corsProxy: get().corsProxy,
-    showBackupCompleteSheet: get().showBackupCompleteSheet
+    backupDirectoryAndroid: undefined
   };
 
   MMKV.setString("appSettings", JSON.stringify(settings));

apps/mobile/native/android/app/build.gradle

@@ -116,7 +116,7 @@ android {
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
         multiDexEnabled true
-        versionCode 3045
+        versionCode 3037
         versionName getNpmVersion()
         testBuildType System.getProperty('testBuildType', 'debug')
         testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'

apps/mobile/native/android/app/proguard-rules.pro

@@ -62,5 +62,4 @@
 #Gson
 -keepattributes Signature
 -keep class com.google.gson.reflect.TypeToken { *; }
--keep class * extends com.google.gson.reflect.TypeToken
--keep class com.streetwriters.notesnook.datatypes.* { *; }
+-keep class * extends com.google.gson.reflect.TypeToken

apps/mobile/native/android/app/src/main/AndroidManifest.xml

@@ -60,7 +60,6 @@
         android:theme="@style/BootTheme"
         android:largeHeap="true"
         android:supportsRtl="false"
-        android:networkSecurityConfig="@xml/network_security_config"
         tools:replace="android:supportsRtl">
 
         <receiver android:exported="false" android:label="@string/reminders_title" android:name=".ReminderWidgetProvider">

apps/mobile/native/android/releasenotes/whatsnew-en-US

@@ -1,3 +1,6 @@
-- Small bug fixes and improvements
+- Added a widget to add a note to home screen for quick access
+- Added a widget that shows upcoming reminders on home screen
+- Now you can share an image with other apps from image viewer
+- Many small bug fixes and improvements
 
 Thank you for using Notesnook!

apps/mobile/native/ios/Notesnook.xcodeproj/project.pbxproj

@@ -1063,7 +1063,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 2130;
+				CURRENT_PROJECT_VERSION = 2124;
 				DEVELOPMENT_TEAM = 53CWBG3QUC;
 				ENABLE_BITCODE = NO;
 				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64;
@@ -1137,7 +1137,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 3.0.33;
+				MARKETING_VERSION = 3.0.27;
 				OTHER_LDFLAGS = (
 					"$(inherited)",
 					"-ObjC",
@@ -1168,7 +1168,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 2130;
+				CURRENT_PROJECT_VERSION = 2124;
 				DEVELOPMENT_TEAM = "";
 				"DEVELOPMENT_TEAM[sdk=iphoneos*]" = 53CWBG3QUC;
 				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64;
@@ -1242,7 +1242,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 3.0.33;
+				MARKETING_VERSION = 3.0.27;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_LDFLAGS = (
 					"$(inherited)",
@@ -1401,7 +1401,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 2130;
+				CURRENT_PROJECT_VERSION = 2124;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DEVELOPMENT_TEAM = 53CWBG3QUC;
 				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64;
@@ -1413,7 +1413,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 3.0.33;
+				MARKETING_VERSION = 3.0.27;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = org.streetwriters.notesnook.notewidget;
@@ -1444,7 +1444,7 @@
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution";
 				CODE_SIGN_STYLE = Manual;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 2130;
+				CURRENT_PROJECT_VERSION = 2124;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEVELOPMENT_TEAM = "";
 				"DEVELOPMENT_TEAM[sdk=iphoneos*]" = 53CWBG3QUC;
@@ -1457,7 +1457,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 3.0.33;
+				MARKETING_VERSION = 3.0.27;
 				MTL_FAST_MATH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = org.streetwriters.notesnook.notewidget;
 				PRODUCT_NAME = "$(TARGET_NAME)";
@@ -1487,7 +1487,7 @@
 				CODE_SIGN_ENTITLEMENTS = "Make Note/Make Note.entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 2130;
+				CURRENT_PROJECT_VERSION = 2124;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DEVELOPMENT_TEAM = 53CWBG3QUC;
 				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64;
@@ -1561,7 +1561,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 3.0.33;
+				MARKETING_VERSION = 3.0.27;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = org.streetwriters.notesnook.share;
@@ -1592,7 +1592,7 @@
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution";
 				CODE_SIGN_STYLE = Manual;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 2130;
+				CURRENT_PROJECT_VERSION = 2124;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEVELOPMENT_TEAM = "";
 				"DEVELOPMENT_TEAM[sdk=iphoneos*]" = 53CWBG3QUC;
@@ -1667,7 +1667,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 3.0.33;
+				MARKETING_VERSION = 3.0.27;
 				MTL_FAST_MATH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = org.streetwriters.notesnook.share;
 				PRODUCT_NAME = "$(TARGET_NAME)";

apps/mobile/native/ios/Podfile

@@ -82,7 +82,6 @@ target 'Make Note' do
   pod "RNDeviceInfo", :path =>  '../../node_modules/react-native-device-info'
   pod "RNPrivacySnapshot", :path =>  '../../node_modules/react-native-privacy-snapshot'
   pod "react-native-theme-switch-animation", :path => '../../node_modules/react-native-theme-switch-animation'
-  pod "react-native-image-resizer", :path => '../../node_modules/@bam.tech/react-native-image-resizer'
 end
 
 

apps/mobile/native/ios/Podfile.lock

@@ -1019,7 +1019,7 @@ PODS:
   - react-native-screenguard (1.0.0):
     - React-Core
     - SDWebImage (~> 5.11.1)
-  - react-native-share-extension (2.9.0):
+  - react-native-share-extension (2.8.0):
     - React
   - react-native-sodium (1.6.1):
     - React
@@ -1820,7 +1820,7 @@ SPEC CHECKSUMS:
   Base64: cecfb41a004124895a7bcee567a89bae5a89d49b
   BEMCheckBox: 5ba6e37ade3d3657b36caecc35c8b75c6c2b1a4e
   boost: d3f49c53809116a5d38da093a8aa78bf551aed09
-  callstack-repack: 721b034d0662f47388719bf26c00f838da6880d5
+  callstack-repack: 2db7cbeced7cd5da360d01965e0b983f6dacfd54
   DoubleConversion: 76ab83afb40bddeeee456813d9c04f67f78771b5
   FBLazyVector: ac12dc084d1c8ec4cc4d7b3cf1b0ebda6dab85af
   fmt: 4c2741a687cc09f0634a2e2c72a838b99f1ff120
@@ -1831,111 +1831,111 @@ SPEC CHECKSUMS:
   MMKV: 817ba1eea17421547e01e087285606eb270a8dcb
   MMKVCore: af055b00e27d88cd92fad301c5fecd1ff9b26dd9
   pop: d582054913807fd11fd50bfe6a539d91c7e1a55a
-  RCT-Folly: 5dc73daec3476616d19e8a53f0156176f7b55461
+  RCT-Folly: 02617c592a293bd6d418e0a88ff4ee1f88329b47
   RCTDeprecation: 3afceddffa65aee666dafd6f0116f1d975db1584
   RCTRequired: ec1239bc9d8bf63e10fb92bd8b26171a9258e0c1
   RCTTypeSafety: f5ecbc86c5c5fa163c05acb7a1c5012e15b5f994
   React: fc9fa7258eff606f44d58c5b233a82dc9cf09018
   React-callinvoker: e3fab14d69607fb7e8e3a57e5a415aed863d3599
-  React-Codegen: ff6c425afab9288a1573337111741d30363bf962
-  React-Core: c3f589f104983dec3c3eeec5e70d61aa811bc236
-  React-CoreModules: 864932ddae3ead5af5bfb05f9bbc2cedcb958b39
-  React-cxxreact: bd9146108c44e6dbb99bba4568ce7af0304a2419
+  React-Codegen: 49efb5917c904b5b01ef708311a2f1773f4fe73e
+  React-Core: 3a5fd9e781cecf87803e5b091496a606a3df774a
+  React-CoreModules: cbf4707dafab8f9f826ac0c63a07d0bf5d01e256
+  React-cxxreact: 7b188556271e3c7fdf22a04819f6a6225045b9dd
   React-debug: d30893c49ae1bce4037ea5cd8bb2511d2a38d057
-  React-Fabric: a171830e52baf8ec2b175c6a3791e01bbb92f1fb
-  React-FabricImage: ad154af0067f4b5dc5a41f607e48ee343641e903
+  React-Fabric: 826729dd2304fda9b89ff0a579f60ba2a470bc26
+  React-FabricImage: 2ad1fb8ffa5778eda9ed204a7b3cdd70bc333ce7
   React-featureflags: 4ae83e72d9a92452793601ac9ac7d2280e486089
-  React-graphics: ed7d57965140168de86835946e8f1210c72c65dc
-  React-hermes: 177b1efdf3b8f10f4ca12b624b83fb4d4ccb2884
-  React-ImageManager: 3a50d0ee0bf81b1a6f23a0c5b30388293bcd6004
-  React-jserrorhandler: dcd62f5ca1c724c19637595ef7f45b78018e758f
-  React-jsi: 0abe1b0881b67caf8d8df6a57778dd0d3bb9d9a5
-  React-jsiexecutor: f6ca8c04f19f6a3acaa9610f7fb728f39d6e3248
-  React-jsinspector: db98771eae84e6f86f0ca5d9dcc572baadbfefc0
-  React-jsitracing: f8367edacc50bb3f9f056a5aeafb8cee5849fafb
-  React-logger: 780b9ee9cec7d44eabc4093de90107c379078cb6
-  React-Mapbuffer: f544f00b98dbdd8cbae96dd2bdb8b47f719976e0
-  react-native-actions-shortcuts: 65fb9cb4a58c71af7382663c1822dda061dbf1b0
-  react-native-background-actions: 40e09df6ea8c7d2753f6c1d75f6f1eee4a9bc35f
-  react-native-begin-background-task: 2191f2a84b0328932a3d44db4361e666fee781bb
-  react-native-blob-util: 4be49d669870f01645b63d33342718e95d0d48b1
-  react-native-config: 136f9755ccc991cc6438053a44363259ad4c7813
-  react-native-date-picker: bbf77c50dce9da2beb11e2f67f3300195ba27d81
-  react-native-document-picker: f4ccd6f6f369da1409e609788181eac66cc1a2d8
-  react-native-fingerprint-scanner: 562585260768cad51ae48e4b505d28c8731aecfa
-  react-native-get-random-values: 419569b6ed3d15bfb9b6781b2f2e058f8e8d2698
-  react-native-gzip: 8d602277c2564591f04dd1cec4043acc8350dcc3
-  react-native-html-to-pdf-lite: d606d3b72d9696c7a6d1e5f5b7536783faacef14
-  react-native-image-resizer: ff3c9ab0ce235c4c00f49d0a373043cb4b8781be
-  react-native-in-app-review: b3d1eed3d1596ebf6539804778272c4c65e4a400
-  react-native-keep-awake: bda639e941ce138506c18f1b999dcbf16d4c77b8
-  react-native-mmkv-storage: 8dddc9d16248bc9a4d9566ac5c97c318692d299c
-  react-native-netinfo: 66c9ac0d0ae92a57a9ed99ab8a75429740700c73
-  react-native-notification-sounds: ce106d58df0dd384bccbd2e84fb53accab7cc068
-  react-native-orientation: db2655b95b4123f17e75dcb04ee8b8b1294ce7ee
-  react-native-pdf: da10473ae54555c373c62af671da8fe0eef846e2
-  react-native-quick-sqlite: 80b5b3405bfc92e97b6041d2c2a446800bea6ad7
-  react-native-safe-area-context: b72c4611af2e86d80a59ac76279043d8f75f454c
-  react-native-screenguard: 82437eeb0086a90b5e5d7e54130bb04fb406373e
-  react-native-share-extension: bcb7e466390a9e50c742f4b1019d6f181aedd7ad
-  react-native-sodium: ed020d5f50ab1886f7bf23e32732d0d10e9373ac
-  react-native-theme-switch-animation: 64f2688c2e3489ababc7b35f436fd3b5ed7c0a98
-  react-native-webview: a71525b1ab760230fbf37303d8371fbe72051c7d
+  React-graphics: 61a026e1c1e7e20d20ac9fec6f6de631732b233d
+  React-hermes: a7054fbcbda3957e3c5eaad06ef9bf79998d535a
+  React-ImageManager: 2bbd6eb2e696bc680f76f84563e4b87d241614e1
+  React-jserrorhandler: 56fa04d49bfbe54ddfece7916673a73ebfea286b
+  React-jsi: f3ce1dd2e950b6ad12b65ea3ef89168f1b94c584
+  React-jsiexecutor: b4df3a27973d82f9abf3c4bd0f88e042cda25f16
+  React-jsinspector: 97ea746c023687de7313ee289817d6991d596c7d
+  React-jsitracing: 3b6060bbf5317663667e1dd93560c7943ab86ccc
+  React-logger: 257858bd55f3a4e1bc0cf07ddc8fb9faba6f8c7c
+  React-Mapbuffer: 6c1cacdbf40b531f549eba249e531a7d0bfd8e7f
+  react-native-actions-shortcuts: 5d9cf0c9c308333dfcc1e05c3f9afa8c428e2533
+  react-native-background-actions: 2c251c986f23347f9c1722f05fd296938f60edb1
+  react-native-begin-background-task: 3b889e07458afc5822a7277cf9cbc7cd077e39ee
+  react-native-blob-util: 2d36383bb52c15c5451be81cb7ddf22bc34a12a6
+  react-native-config: 86038147314e2e6d10ea9972022aa171e6b1d4d8
+  react-native-date-picker: 93e43b3084cea595b4d68b1405d6d99849663bd6
+  react-native-document-picker: ec07866a30707f23660c0f3ae591d669d3e89096
+  react-native-fingerprint-scanner: be63e626b31fb951780a5fac5328b065a61a3d6e
+  react-native-get-random-values: dee677497c6a740b71e5612e8dbd83e7539ed5bb
+  react-native-gzip: c5e87ee9e359f02350e3a2ee52eb35eddc398868
+  react-native-html-to-pdf-lite: 21bfb169bf4cbcd7bec9f736975ee1b3f5292d4a
+  react-native-image-resizer: 00ceb0e05586c7aadf061eea676957a6c2ec60fa
+  react-native-in-app-review: db8bb167a5f238e7ceca5c242d6b36ce8c4404a4
+  react-native-keep-awake: caee3ff89eaa21dfe29010f0d143566874a04441
+  react-native-mmkv-storage: 3892853c11ab8a0c3a3f9ef3b0657aa9a5f616c9
+  react-native-netinfo: ccbe1085dffd16592791d550189772e13bf479e2
+  react-native-notification-sounds: da78c828fe1bcbb92d8b505d5261890ed315ff39
+  react-native-orientation: f1caf84d65f1a4fd4511a18f2b924e634ad7a628
+  react-native-pdf: 33c622cbdf776a649929e8b9d1ce2d313347c4fa
+  react-native-quick-sqlite: 18e1367c34faac90e37f6eb3e78c196e9b674b5d
+  react-native-safe-area-context: b7daa1a8df36095a032dff095a1ea8963cb48371
+  react-native-screenguard: 8b36a3df84c76cd2b82c477f71c26fa1c8cc14a0
+  react-native-share-extension: 01b25fc15faf2510cc2529e98ca444f64e46238d
+  react-native-sodium: 4cb76086943a7f60c42b40ebca866695b360a196
+  react-native-theme-switch-animation: d3eb50365a3829ce5572628888fa514752703f61
+  react-native-webview: 553abd09f58e340fdc7746c9e2ae096839e99911
   React-nativeconfig: ba9a2e54e2f0882cf7882698825052793ed4c851
-  React-NativeModulesApple: 84aaad2b0e546d7b839837ca537f6e72804a4cad
+  React-NativeModulesApple: 8d11ff8955181540585c944cf48e9e7236952697
   React-perflogger: ed4e0c65781521e0424f2e5e40b40cc7879d737e
   React-RCTActionSheet: 49d53ff03bb5688ca4606c55859053a0cd129ea5
-  React-RCTAnimation: 3075449f26cb98a52bcbf51cccd0c7954e2a71db
-  React-RCTAppDelegate: 9a419c4dda9dd039ad851411546dd297b930c454
-  React-RCTBlob: e81ab773a8fc1e9dceed953e889f936a7b7b3aa6
-  React-RCTFabric: 47a87a3e3fa751674f7e64d0bcd58976b8c57db9
-  React-RCTImage: d570531201c6dce7b5b63878fa8ecec0cc311c4c
-  React-RCTLinking: af888972b925d2811633d47853c479e88c35eb4d
-  React-RCTNetwork: 5728a06ff595003eca628f43f112a804f4a9a970
-  React-RCTSettings: ba3665b0569714a8aaceee5c7d23b943e333fa55
-  React-RCTText: b733fa984f0336b072e47512898ba91214f66ddb
-  React-RCTVibration: 0cbcbbd8781b6f6123671bae9ee5dd20d621af6c
-  React-rendererdebug: 9fc8f7d0bd19f2a3fe3791982af550b5e1535ff7
+  React-RCTAnimation: 07b4923885c52c397c4ec103924bf6e53b42c73e
+  React-RCTAppDelegate: 316e295076734baf9bdf1bfac7d92ab647aed930
+  React-RCTBlob: 85c57b0d5e667ff8a472163ba3af0628171a64bb
+  React-RCTFabric: 97c1465ded4dc92841f5376a39e43e1b2c455f40
+  React-RCTImage: b965c85bec820e2a9c154b1fb00a2ecdd59a9c92
+  React-RCTLinking: 75f04a5f27c26c4e73a39c50df470820d219df79
+  React-RCTNetwork: c1a9143f4d5778efc92da40d83969d03912ccc24
+  React-RCTSettings: c6800f91c0ecd48868cd5db754b0b0a7f5ffe039
+  React-RCTText: b923e24f9b7250bc4f7ab154c4168ad9f8d8fc9d
+  React-RCTVibration: 08c4f0c917c435b3619386c25a94ee5d64c250f0
+  React-rendererdebug: 3cda04217d9df67b94397ee0ead8ef3d8b7e427b
   React-rncore: 4013508a2f3fcf46c961919bbbd4bfdda198977e
-  React-RuntimeApple: a852a6e06ab20711658873f39cb10b0033bea19d
-  React-RuntimeCore: 12e5e176c0cb09926f3e6f37403a84d2e0f203a7
+  React-RuntimeApple: 447844a2bdb0a03ffd24e5b4a4b96cfc50325b88
+  React-RuntimeCore: 9b5bffdaccee9b707b1c2694c9044e13ff0bb087
   React-runtimeexecutor: 0e688aefc14c6bc8601f4968d8d01c3fb6446844
-  React-RuntimeHermes: 80c03a5215520c9733764ba11cbe535053c9746d
-  React-runtimescheduler: 2cbd0f3625b30bba08e8768776107f6f0203159b
-  React-utils: 9fa4e5d0b5e6c6c85c958f19d6ef854337886417
-  ReactCommon: 9f285823dbe955099978d9bff65a7653ca029256
-  RNBackgroundFetch: 0c49d5892a0e2f9c139e24ba498985cf0bf070c6
-  RNBootSplash: 3bc12ecb62f69c5af6e6ddf0e6bef88f572ccdb5
-  RNCCheckbox: df88c1c78a17869da84bb031c9d8185d417398a6
-  RNCClipboard: efe1b27ad1ea378c60c8c8aabfd130961bbeb474
-  RNCMaskedView: 4b5b12efdee55966f1d68f32d4b3401c2acf05c2
-  RNDateTimePicker: 818460dc31b0dc5ec58289003e27dd8d022fb79c
-  RNDeviceInfo: d3e91ffb33ee97a7982108476edb68cb3672efa6
-  RNExitApp: 890cce29b4e01372c84b3b775f9a63f90d77de19
-  RNFileViewer: 4b5d83358214347e4ab2d4ca8d5c1c90d869e251
-  RNFlashList: fe872a2d1b4c859c64a7d7421628a1308ebb9e4f
-  RNGestureHandler: 61302deb50c92cba160f5a11f00f69da48116724
-  RNIap: aa38c2cc8a2a75ba8112d161ca084a0b611955df
-  RNImageCropPicker: 30d770b383d84e1067d82ea7b5ed4fff851bbbb2
-  RNKeychain: ffd0513e676445c637410b47249460cbf56bc9cb
-  RNNotifee: b98fb71f678f6644fa48ec6d515ec6fcfc5214ba
-  RNPrivacySnapshot: ccad3a548338c2f526bb7b1789af3fb0618b7d1d
-  RNReanimated: bee9626cf4920f2910bf7c4f8a3dc569161a9475
-  RNScreens: d0db5e9f28afd284a5193474d6be949f4cba888e
-  RNSecureRandom: b64d263529492a6897e236a22a2c4249aa1b53dc
-  RNShare: 5d7762ded21e1fff97dda6d41e963e22dce2d025
-  RNSVG: d7cb8bd34550cf4c4fc7edd7ac627905e2b71f3f
-  RNTooltips: 50ff94bd2bff84ef74279c9532d008f5fdcddb95
-  RNZipArchive: 71befbdc20e7fbd4b64552a0b324ad0e8d0efefb
+  React-RuntimeHermes: 4d6ef6bb0f2b0b40d59143317f6b99c82764c959
+  React-runtimescheduler: cfbe85c3510c541ec6dc815c7729b41304b67961
+  React-utils: f242eb7e7889419d979ca0e1c02ccc0ea6e43b29
+  ReactCommon: f7da14a8827b72704169a48c929bcde802698361
+  RNBackgroundFetch: 35c7183f6eeff69396d42c4b206e1ae2a21e9327
+  RNBootSplash: de2c568373a9c79a66e9918b8929eb6c9a35246f
+  RNCCheckbox: 43bcc6493611468af0e19f19f029dab3da8561c4
+  RNCClipboard: 3f0451a8100393908bea5c5c5b16f96d45f30bfc
+  RNCMaskedView: 949696f25ec596bfc697fc88e6f95cf0c79669b6
+  RNDateTimePicker: 40ffda97d071a98a10fdca4fa97e3977102ccd14
+  RNDeviceInfo: aad3c663b25752a52bf8fce93f2354001dd185aa
+  RNExitApp: c4e052df2568b43bec8a37c7cd61194d4cfee2c3
+  RNFileViewer: ce7ca3ac370e18554d35d6355cffd7c30437c592
+  RNFlashList: e9b57a5553639f9b528cc50ab53f25831722ed62
+  RNGestureHandler: 4fd316f1bdb8d7f6a54efc58da5923cb83014b19
+  RNIap: 17583f958d35788a87948e94072ff6edd3580497
+  RNImageCropPicker: d9616a0cb9b72e8551ff94a7a5021fbd29050aa5
+  RNKeychain: 840f8e6f13be0576202aefcdffd26a4f54bfe7b5
+  RNNotifee: 1448fd16c2a6f3e8abbc219801bf5be2435183e5
+  RNPrivacySnapshot: 8eaf571478a353f2e5184f5c803164f22428b023
+  RNReanimated: 7212582b487bceed64b2dbc6c15777b97922be21
+  RNScreens: d2a12528d1abe4922e7ee5c9a00dd40c827c2ab5
+  RNSecureRandom: 07efbdf2cd99efe13497433668e54acd7df49fef
+  RNShare: 22717e910836a66cb7255b3b8c4ab06cbe346e27
+  RNSVG: d7d7bc8229af3842c9cfc3a723c815a52cdd1105
+  RNTooltips: 5424d4bf0b3d441104127943b1115cc7f0616b1f
+  RNZipArchive: 9d90367b1573903b5561a8c0b911e5cc12626e74
   SDWebImage: a7f831e1a65eb5e285e3fb046a23fcfbf08e696d
   SexyTooltip: 5c9b4dec52bfb317938cb0488efd9da3717bb6fd
   SocketRocket: abac6f5de4d4d62d24e11868d7a2f427e0ef940d
   SSZipArchive: fe6a26b2a54d5a0890f2567b5cc6de5caa600aef
   SwiftyRSA: 8c6dd1ea7db1b8dc4fb517a202f88bb1354bc2c6
   TOCropViewController: 80b8985ad794298fb69d3341de183f33d1853654
-  toolbar-android: c426ed5bd3dcccfed20fd79533efc0d1ae0ef018
+  toolbar-android: 2a73856e98b750d7e71ce4644d3f41cc98211719
   Yoga: 950bbfd7e6f04790fdb51149ed51df41f329fcc8
 
-PODFILE CHECKSUM: 95f23a5abb88f81f8ca90e24a0a8ceae0a2d1028
+PODFILE CHECKSUM: aa07aca16c1d92394d8ce12f2c5fcaa8a3ae4997
 
 COCOAPODS: 1.16.2

apps/mobile/native/package.json

@@ -73,7 +73,7 @@
     "react-native-begin-background-task": "github:blockfirm/react-native-begin-background-task",
     "react-native-privacy-snapshot": "github:standardnotes/react-native-privacy-snapshot",
     "@ammarahmed/react-native-fingerprint-scanner": "^5.0.0",
-    "@ammarahmed/react-native-share-extension": "^2.9.0"
+    "@ammarahmed/react-native-share-extension": "^2.8.0"
   },
   "devDependencies": {
     "detox": "^20.27.6",

apps/mobile/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@notesnook/mobile",
-  "version": "3.0.31",
+  "version": "3.0.27",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@notesnook/mobile",
-      "version": "3.0.31",
+      "version": "3.0.27",
       "hasInstallScript": true,
       "license": "GPL-3.0-or-later",
       "workspaces": [
@@ -14,7 +14,6 @@
         "app/"
       ],
       "dependencies": {
-        "@ammarahmed/react-native-share-extension": "^2.9.0",
         "@notesnook/common": "file:../../packages/common",
         "@notesnook/core": "file:../../packages/core",
         "@notesnook/crypto": "file:../../packages/crypto",
@@ -3822,7 +3821,6 @@
         "@lingui/react": "5.1.2",
         "@mdi/js": "^7.2.96",
         "@mdi/react": "^1.6.0",
-        "@notesnook/common": "file:../common",
         "@notesnook/editor": "file:../editor",
         "@notesnook/intl": "file:../intl",
         "@notesnook/theme": "file:../theme",
@@ -3833,7 +3831,6 @@
         "react": "^18.2.0",
         "react-dom": "^18.2.0",
         "react-freeze": "^1.0.3",
-        "tinycolor2": "1.6.0",
         "zustand": "^4.4.7"
       },
       "devDependencies": {
@@ -28271,12 +28268,7 @@
         "@readme/data-urls": "3.0.0",
         "@streetwriters/kysely": "^0.27.4",
         "@streetwriters/showdown": "^3.0.1-alpha.2",
-        "@tanstack/react-query": "^4.36.1",
-        "@trpc/client": "^10.45.2",
-        "@trpc/react-query": "^10.45.2",
-        "@trpc/server": "^10.45.2",
         "absolutify": "^0.1.0",
-        "async-mutex": "0.5.0",
         "buffer": "^6.0.3",
         "dayjs": "^1.11.13",
         "deprecated-react-native-prop-types": "^4.1.0",
@@ -28315,6 +28307,7 @@
         "@ammarahmed/react-native-background-fetch": "^4.2.2",
         "@ammarahmed/react-native-eventsource": "1.1.0",
         "@ammarahmed/react-native-fingerprint-scanner": "^5.0.0",
+        "@ammarahmed/react-native-share-extension": "^2.8.0",
         "@ammarahmed/react-native-sodium": "^1.6.1",
         "@bam.tech/react-native-image-resizer": "3.0.5",
         "@callstack/repack": "^4.1.1",
@@ -28452,10 +28445,9 @@
       }
     },
     "node_modules/@ammarahmed/react-native-share-extension": {
-      "version": "2.9.0",
-      "resolved": "https://registry.npmjs.org/@ammarahmed/react-native-share-extension/-/react-native-share-extension-2.9.0.tgz",
-      "integrity": "sha512-iEkpJQFZL5/WDPh7iRCLZREANgaaAHthDsPaAYT6sI4wieQcHZMBAnfRMwBEnC0BZ0WVxbQZdzJYez+dmwpr2g==",
-      "license": "MIT",
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@ammarahmed/react-native-share-extension/-/react-native-share-extension-2.8.0.tgz",
+      "integrity": "sha512-eDFVKiJJxjnIORveMUKVJGIhKfRNjqJWIoKS+JM88q8I8e3jHys9moyJAr9QM5oW/tZx4yyItl08yRXGnr7Grg==",
       "dependencies": {
         "react-native": "^0.63.1"
       }
@@ -34604,14 +34596,6 @@
       "version": "1.0.1",
       "license": "MIT"
     },
-    "node_modules/async-mutex": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/async-mutex/-/async-mutex-0.5.0.tgz",
-      "integrity": "sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==",
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
     "node_modules/at-least-node": {
       "version": "1.0.0",
       "dev": true,
@@ -43381,7 +43365,6 @@
       "resolved": "https://registry.npmjs.org/react-test-renderer/-/react-test-renderer-18.2.0.tgz",
       "integrity": "sha512-JWD+aQ0lh2gvh4NM3bBM42Kx+XybOxCpgYK7F8ugAlpaTSnWsX+39Z4XkOykGZAHrjwwTZT3x3KxswVWxHPUqA==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "react-is": "^18.2.0",
         "react-shallow-renderer": "^16.15.0",

apps/mobile/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notesnook/mobile",
-  "version": "3.0.33",
+  "version": "3.0.27",
   "private": true,
   "license": "GPL-3.0-or-later",
   "workspaces": [

apps/mobile/share/editor.js

@@ -21,11 +21,13 @@ import React, {
   useCallback,
   useEffect,
   useLayoutEffect,
+  useMemo,
   useRef,
   useState
 } from "react";
 import { Linking, Platform, TextInput, View } from "react-native";
 import { WebView } from "react-native-webview";
+import Commands from "../app/screens/editor/tiptap/commands";
 import {
   eSubscribeEvent,
   eUnSubscribeEvent
@@ -55,6 +57,7 @@ export async function post(ref, type, value = null) {
 const useEditor = () => {
   const ref = useRef();
   const { colors } = useThemeColors("editor");
+  const commands = useMemo(() => new Commands(ref), [ref]);
   const currentNote = useRef();
 
   const postMessage = useCallback(
@@ -103,7 +106,7 @@ const useEditor = () => {
     }, 1);
   };
 
-  return { ref, onLoad, currentNote };
+  return { ref, onLoad, currentNote, commands };
 };
 
 const useEditorEvents = (editor, onChange) => {

apps/mobile/share/share.js

@@ -546,7 +546,7 @@ const ShareView = () => {
                     </Paragraph>
                     <ScrollView horizontal>
                       {rawFiles.map((item) =>
-                        isImage(item.type) || item.value?.endsWith(".png") ? (
+                        isImage(item.type) ? (
                           <TouchableOpacity
                             onPress={() => onRemoveFile(item)}
                             key={item.name}
@@ -604,8 +604,7 @@ const ShareView = () => {
                                 paddingRight: 8
                               }}
                             >
-                              {item.name || item.value.split("/").pop()}
-                              {item.size ? `(${formatBytes(item.size)})` : ""}
+                              {item.name} ({formatBytes(item.size)})
                             </Paragraph>
                           </TouchableOpacity>
                         )

apps/monograph/Dockerfile

@@ -1,5 +1,5 @@
 
-FROM oven/bun:1.2.2-alpine
+FROM --platform=$BUILDPLATFORM oven/bun:1.1.36-alpine
 
 RUN mkdir -p /home/bun/app && chown -R bun:bun /home/bun/app
 
@@ -11,4 +11,4 @@ COPY --chown=bun:bun output .
 
 RUN bun install
 
-CMD [ "bun", "run", "start" ]
+CMD [ "bun", "run", "start" ]

apps/monograph/app/entry.server.tsx

@@ -62,42 +62,8 @@ export default function handleRequest(
 
   responseHeaders.set("Content-Type", "text/html; charset=utf-8");
 
-  const nonce =
-    remixContext.staticHandlerContext?.loaderData?.root?.cspScriptNonce;
-  if (nonce)
-    responseHeaders.set(
-      "Content-Security-Policy",
-      getContentSecurityPolicy(nonce)
-    );
-
   return new Response(html, {
     status: responseStatusCode,
     headers: responseHeaders
   });
 }
-
-function getContentSecurityPolicy(nonce?: string) {
-  let script_src: string;
-  if (typeof nonce === "string") {
-    script_src = `'self' 'report-sample' 'nonce-${nonce}'`;
-  } else if (process.env.NODE_ENV === "development") {
-    // Allow the <LiveReload /> component to load without a nonce in the error pages
-    script_src = "'self' 'report-sample'";
-  } else {
-    script_src = "'self' 'report-sample'";
-  }
-
-  const connect_src =
-    process.env.NODE_ENV === "development"
-      ? "'self' ws://localhost:*"
-      : "'self'";
-
-  return (
-    `script-src ${script_src} 'strict-dynamic'; ` +
-    `connect-src ${connect_src}; ` +
-    "form-action 'self'; " +
-    "object-src 'none'; " +
-    "block-all-mixed-content; " +
-    "base-uri 'self'; manifest-src 'self'"
-  );
-}

apps/monograph/app/root.tsx

@@ -22,22 +22,14 @@ import {
   Meta,
   Outlet,
   Scripts,
-  ScrollRestoration,
-  useLoaderData
+  ScrollRestoration
 } from "@remix-run/react";
 import { BaseThemeProvider } from "./components/theme-provider";
 import { Buffer } from "buffer";
 import { ThemeDark, themeToCSS } from "@notesnook/theme";
-import { LoaderFunction } from "@remix-run/node";
 
 globalThis.Buffer = Buffer;
 
-type RootLoaderData = { cspScriptNonce: string };
-export const loader: LoaderFunction = async () => {
-  const crypto = await import("node:crypto");
-  return { cspScriptNonce: crypto.randomBytes(16).toString("hex") };
-};
-
 export function Head() {
   return (
     <>
@@ -48,17 +40,13 @@ export function Head() {
       <Links />
       <style
         id="theme-colors"
-        dangerouslySetInnerHTML={{ __html: themeToCSS(ThemeDark) }}
+        dangerouslySetInnerHTML={{ __html: colorsToCSS() }}
       />
     </>
   );
 }
 
 export default function App() {
-  const data = useLoaderData<RootLoaderData>();
-  const cspScriptNonce =
-    typeof document === "undefined" ? data.cspScriptNonce : "";
-
   return (
     <>
       <BaseThemeProvider
@@ -68,8 +56,29 @@ export default function App() {
       >
         <Outlet />
       </BaseThemeProvider>
-      <ScrollRestoration nonce={cspScriptNonce} />
-      <Scripts nonce={cspScriptNonce} />
+      <ScrollRestoration />
+      <Scripts />
     </>
   );
 }
+
+function colorsToCSS() {
+  // const colorScheme = JSON.parse(
+  //   window.localStorage.getItem("colorScheme") || '"light"'
+  // );
+  // const root = document.querySelector("html");
+  // if (root) root.setAttribute("data-theme", colorScheme);
+
+  // const theme =
+  //   colorScheme === "dark"
+  //     ? JSON.parse(window.localStorage.getItem("theme:dark") || "false") ||
+  //       ThemeDark
+  //     : JSON.parse(window.localStorage.getItem("theme:light") || "false") ||
+  //       ThemeLight;
+  //  const stylesheet = document.getElementById("theme-colors");
+  // if (theme) {
+  //   const css = ;
+  //   if (stylesheet) stylesheet.innerHTML = css;
+  // } else stylesheet?.remove();
+  return themeToCSS(ThemeDark);
+}

apps/monograph/package-lock.json

@@ -1,18 +1,18 @@
 {
   "name": "@notesnook/monograph",
-  "version": "1.2.4",
+  "version": "1.2.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@notesnook/monograph",
-      "version": "1.2.4",
+      "version": "1.2.2",
       "dependencies": {
         "@emotion/cache": "11.11.0",
         "@emotion/react": "11.11.1",
         "@emotion/server": "11.11.0",
-        "@lingui/core": "5.1.2",
-        "@lingui/react": "5.1.2",
+        "@lingui/core": "4.11.4",
+        "@lingui/react": "4.11.4",
         "@mdi/js": "^7.4.47",
         "@napi-rs/canvas": "0.1.59",
         "@notesnook/core": "file:../../packages/core",
@@ -60,6 +60,9 @@
         "vite-plugin-static-copy": "^2.1.0",
         "vite-tsconfig-paths": "^5.0.1",
         "wrangler": "3.78.11"
+      },
+      "engines": {
+        "node": ">=20.0.0"
       }
     },
     "../../packages/core": {
@@ -75,16 +78,16 @@
         "@streetwriters/kysely": "^0.27.4",
         "@streetwriters/showdown": "^3.0.9-alpha",
         "@types/mime-db": "^1.43.5",
-        "async-mutex": "0.5.0",
-        "dayjs": "1.11.13",
+        "async-mutex": "^0.3.2",
+        "dayjs": "1.11.9",
         "dom-serializer": "^2.0.0",
         "domhandler": "^5.0.3",
         "domutils": "^3.1.0",
-        "entities": "5.0.0",
+        "entities": "^4.3.1",
         "fuzzyjs": "^5.0.1",
         "html-to-text": "^9.0.5",
         "htmlparser2": "^8.0.1",
-        "katex": "0.16.11",
+        "katex": "0.16.2",
         "linkedom": "^0.14.17",
         "liqe": "^1.13.0",
         "mime-db": "^1.53.0",
@@ -92,33 +95,33 @@
         "qclone": "^1.2.0",
         "rfdc": "^1.3.0",
         "spark-md5": "^3.0.2",
-        "sqlite-better-trigram": "0.0.2"
+        "sqlite-better-trigram": "^0.0.1"
       },
       "devDependencies": {
         "@notesnook/crypto": "file:../crypto",
         "@types/better-sqlite3": "^7.6.5",
-        "@types/event-source-polyfill": "1.0.5",
+        "@types/event-source-polyfill": "^1.0.1",
         "@types/html-to-text": "^9.0.0",
-        "@types/katex": "0.16.7",
-        "@types/prismjs": "1.26.4",
+        "@types/katex": "^0.16.2",
+        "@types/prismjs": "^1.26.0",
         "@types/spark-md5": "^3.0.2",
         "@types/streetwriters__showdown": "npm:@types/showdown@^2.0.6",
         "@types/unist": "^3.0.3",
         "@types/ws": "^8.5.5",
-        "@vitest/coverage-v8": "2.1.8",
+        "@vitest/coverage-v8": "^1.0.1",
         "abortcontroller-polyfill": "^1.7.3",
-        "better-sqlite3-multiple-ciphers": "11.5.0",
+        "better-sqlite3-multiple-ciphers": "^11.5.0",
         "bson-objectid": "^2.0.4",
-        "dotenv": "16.4.7",
-        "event-source-polyfill": "1.0.31",
+        "dotenv": "^16.0.1",
+        "event-source-polyfill": "^1.0.31",
         "eventsource": "^2.0.2",
-        "hash-wasm": "4.12.0",
+        "hash-wasm": "^4.9.0",
         "isomorphic-fetch": "^3.0.0",
         "mockdate": "^3.0.5",
-        "nanoid": "5.0.7",
+        "nanoid": "^5.0.1",
         "otplib": "^12.0.1",
         "refractor": "^4.8.1",
-        "vitest": "2.1.8",
+        "vitest": "^1.0.1",
         "vitest-fetch-mock": "^0.2.2",
         "ws": "^8.13.0"
       }
@@ -171,14 +174,14 @@
         "@tiptap/pm": "2.6.6",
         "@tiptap/starter-kit": "2.6.6",
         "alfaaz": "^1.1.0",
-        "async-mutex": "0.5.0",
+        "async-mutex": "^0.5.0",
         "clipboard-polyfill": "4.1.0",
         "colord": "^2.9.3",
         "detect-indent": "^7.0.1",
-        "entities": "5.0.0",
+        "entities": "^5.0.0",
         "katex": "0.16.11",
         "linkifyjs": "^4.1.3",
-        "nanoid": "5.0.7",
+        "nanoid": "^5.0.7",
         "prism-themes": "^1.9.0",
         "prosemirror-codemark": "^0.4.2",
         "prosemirror-view": "1.34.2",
@@ -191,23 +194,23 @@
       },
       "devDependencies": {
         "@emotion/react": "11.11.1",
-        "@mdi/js": "7.4.47",
-        "@theme-ui/components": "0.16.1",
-        "@theme-ui/core": "0.16.1",
-        "@types/katex": "0.16.7",
-        "@types/prismjs": "1.26.4",
-        "@types/react": "18.3.5",
+        "@mdi/js": "^7.4.47",
+        "@theme-ui/components": "^0.16.2",
+        "@theme-ui/core": "^0.16.2",
+        "@types/katex": "^0.16.7",
+        "@types/prismjs": "^1.26.4",
+        "@types/react": "^18.3.5",
         "@types/react-color": "^3.0.12",
-        "@types/react-dom": "18.3.0",
-        "@types/react-modal": "3.16.3",
-        "happy-dom": "16.0.1",
+        "@types/react-dom": "^18.3.0",
+        "@types/react-modal": "^3.16.3 ",
+        "happy-dom": "^15.7.4",
         "isomorphic-fetch": "^3.0.0",
         "nodemon": "^3.1.7",
         "prosemirror-test-builder": "^1.1.1",
         "react": "18.3.1",
         "react-dom": "18.3.1",
-        "react-modal": "3.16.3",
-        "vitest": "2.1.8",
+        "react-modal": "3.16.1",
+        "vitest": "^2.0.5",
         "web-vitals": "^4.2.3",
         "zustand": "4.5.5"
       },
@@ -228,15 +231,16 @@
       "hasInstallScript": true,
       "license": "GPL-3.0-or-later",
       "devDependencies": {
-        "@lingui/cli": "5.1.2",
-        "@lingui/core": "5.1.2",
-        "@lingui/swc-plugin": "5.0.2",
-        "@types/react": "18.3.5",
+        "@lingui/cli": "^4.11.4",
+        "@lingui/macro": "^4.11.4 ",
+        "@lingui/swc-plugin": "^4.0.10",
+        "@types/react": "^18.2.39",
         "babel-plugin-macros": "^3.1.0",
         "nodemon": "^3.1.7",
-        "react": "18.3.1",
+        "react": "18.2.0",
         "rollup": "^4.24.4",
-        "vite": "5.4.11",
+        "typescript": "5.5.3",
+        "vite": "^5.4.8",
         "vite-plugin-dts": "^4.2.3",
         "vite-plugin-static-copy": "^2.0.0",
         "vite-plugin-swc-transform": "^1.0.1"
@@ -253,14 +257,14 @@
       "devDependencies": {
         "@emotion/react": "11.11.1",
         "@theme-ui/color": "^0.16.1",
-        "@theme-ui/components": "0.16.1",
-        "@theme-ui/core": "0.16.1",
-        "@trpc/server": "10.45.2",
-        "@types/react": "18.3.5",
+        "@theme-ui/components": "^0.16.1",
+        "@theme-ui/core": "^0.16.1",
+        "@trpc/server": "^10.45.2",
+        "@types/react": "^18.2.39",
         "isomorphic-fetch": "^3.0.0",
-        "react": "18.3.1",
+        "react": "18.2.0",
         "ts-json-schema-generator": "^1.2.0",
-        "zustand": "4.5.5"
+        "zustand": "4.4.7"
       },
       "peerDependencies": {
         "@emotion/react": ">=11",
@@ -280,16 +284,16 @@
       },
       "devDependencies": {
         "@emotion/react": "11.11.1",
-        "@mdi/js": "7.4.47",
-        "@theme-ui/components": "0.16.1",
-        "@theme-ui/core": "0.16.1",
-        "@types/react": "18.3.5",
-        "@types/react-dom": "18.3.0",
+        "@mdi/js": "^7.2.96",
+        "@theme-ui/components": "^0.16.1",
+        "@theme-ui/core": "^0.16.1",
+        "@types/react": "^18.2.39",
+        "@types/react-dom": "^18.2.17",
         "@types/react-modal": "3.16.3",
-        "mac-scrollbar": "0.13.6",
-        "react": "18.3.1",
-        "react-dom": "18.3.1",
-        "react-modal": "3.16.3"
+        "mac-scrollbar": "^0.10.3",
+        "react": "18.2.0",
+        "react-dom": "18.2.0",
+        "react-modal": "3.16.1"
       },
       "peerDependencies": {
         "@emotion/react": ">=11",
@@ -1656,65 +1660,46 @@
       "dev": true
     },
     "node_modules/@lingui/core": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@lingui/core/-/core-5.1.2.tgz",
-      "integrity": "sha512-biqmMCWuBBj7ERSpgGSV91hTShnSrR/RIFUcNKjWuZYgDd3HpBdEmXKCo9NTanQYbkBUpmyw/bgwsSBex6vkDA==",
+      "version": "4.11.4",
+      "resolved": "https://registry.npmjs.org/@lingui/core/-/core-4.11.4.tgz",
+      "integrity": "sha512-W0bBIFe44s//Qs+RQ+NMfzK5vAm9oEKyDddlN94Db6rzeUT/IJo7N+T75A6Bya8v/BrtF2G/W4b77eS3sd0utw==",
+      "license": "MIT",
       "dependencies": {
         "@babel/runtime": "^7.20.13",
-        "@lingui/message-utils": "^5.1.2",
+        "@lingui/message-utils": "4.11.4",
         "unraw": "^3.0.0"
       },
       "engines": {
-        "node": ">=20.0.0"
-      },
-      "peerDependencies": {
-        "@lingui/babel-plugin-lingui-macro": "5.1.2",
-        "babel-plugin-macros": "2 || 3"
-      },
-      "peerDependenciesMeta": {
-        "@lingui/babel-plugin-lingui-macro": {
-          "optional": true
-        },
-        "babel-plugin-macros": {
-          "optional": true
-        }
+        "node": ">=16.0.0"
       }
     },
     "node_modules/@lingui/message-utils": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@lingui/message-utils/-/message-utils-5.1.2.tgz",
-      "integrity": "sha512-P/N0yBy2MuC726EaGPGiOafc/0RafHiwkvZJdFKjm1/XOMWrFZDPFXTuxguVQ3HQsRi5eUIPaboU4uRX4GepPg==",
+      "version": "4.11.4",
+      "resolved": "https://registry.npmjs.org/@lingui/message-utils/-/message-utils-4.11.4.tgz",
+      "integrity": "sha512-ZTCDhGbj5EN+P9Ajcj0Gq9uDP3HZTRW6/kT09WkiFgL4NayYLksPvgBk29sIglsS6M+Y6Iw2BrUK403SZjZKgw==",
+      "license": "MIT",
       "dependencies": {
         "@messageformat/parser": "^5.0.0",
         "js-sha256": "^0.10.1"
       },
       "engines": {
-        "node": ">=20.0.0"
+        "node": ">=16.0.0"
       }
     },
     "node_modules/@lingui/react": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@lingui/react/-/react-5.1.2.tgz",
-      "integrity": "sha512-YPAvbPUd+kJrmA9H1LSJ9f6+0hkOlm0w8g+7a8FtE7olamjXd7SyIgJMbeJmvKSdztrrdcLBs9YEftUKTfjiyg==",
+      "version": "4.11.4",
+      "resolved": "https://registry.npmjs.org/@lingui/react/-/react-4.11.4.tgz",
+      "integrity": "sha512-f7re4HhjI6CLBV1CY/PcI3VYP5zS4rtfU33speWnfkymsxGIXQv4ol3BqrgPLGhypMl2nKcL5nfL+LewrLIW8g==",
+      "license": "MIT",
       "dependencies": {
         "@babel/runtime": "^7.20.13",
-        "@lingui/core": "^5.1.2"
+        "@lingui/core": "4.11.4"
       },
       "engines": {
-        "node": ">=20.0.0"
+        "node": ">=16.0.0"
       },
       "peerDependencies": {
-        "@lingui/babel-plugin-lingui-macro": "5.1.2",
-        "babel-plugin-macros": "2 || 3",
-        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@lingui/babel-plugin-lingui-macro": {
-          "optional": true
-        },
-        "babel-plugin-macros": {
-          "optional": true
-        }
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
       }
     },
     "node_modules/@mdi/js": {
@@ -1754,9 +1739,10 @@
       }
     },
     "node_modules/@messageformat/parser": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/@messageformat/parser/-/parser-5.1.1.tgz",
-      "integrity": "sha512-3p0YRGCcTUCYvBKLIxtDDyrJ0YijGIwrTRu1DT8gIviIDZru8H23+FkY6MJBzM1n9n20CiM4VeDYuBsrrwnLjg==",
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@messageformat/parser/-/parser-5.1.0.tgz",
+      "integrity": "sha512-jKlkls3Gewgw6qMjKZ9SFfHUpdzEVdovKFtW1qRhJ3WI4FW5R/NnGDqr8SDGz+krWDO3ki94boMmQvGke1HwUQ==",
+      "license": "MIT",
       "dependencies": {
         "moo": "^0.5.1"
       }
@@ -2942,22 +2928,6 @@
         "@styled-system/css": "^5.1.5"
       }
     },
-    "node_modules/@theme-ui/color-modes": {
-      "version": "0.16.2",
-      "resolved": "https://registry.npmjs.org/@theme-ui/color-modes/-/color-modes-0.16.2.tgz",
-      "integrity": "sha512-jWEWx53lxNgWCT38i/kwLV2rsvJz8lVZgi5oImnVwYba9VejXD23q1ckbNFJHosQ8KKXY87ht0KPC6BQFIiHtQ==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@theme-ui/core": "^0.16.2",
-        "@theme-ui/css": "^0.16.2",
-        "deepmerge": "^4.2.2"
-      },
-      "peerDependencies": {
-        "@emotion/react": "^11.11.1",
-        "react": ">=18"
-      }
-    },
     "node_modules/@theme-ui/components": {
       "version": "0.16.2",
       "resolved": "https://registry.npmjs.org/@theme-ui/components/-/components-0.16.2.tgz",
@@ -3003,22 +2973,6 @@
         "@emotion/react": "^11.11.1"
       }
     },
-    "node_modules/@theme-ui/theme-provider": {
-      "version": "0.16.2",
-      "resolved": "https://registry.npmjs.org/@theme-ui/theme-provider/-/theme-provider-0.16.2.tgz",
-      "integrity": "sha512-LRnVevODcGqO0JyLJ3wht+PV3ZoZcJ7XXLJAJWDoGeII4vZcPQKwVy4Lpz/juHsZppQxKcB3U+sQDGBnP25irQ==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@theme-ui/color-modes": "^0.16.2",
-        "@theme-ui/core": "^0.16.2",
-        "@theme-ui/css": "^0.16.2"
-      },
-      "peerDependencies": {
-        "@emotion/react": "^11.11.1",
-        "react": ">=18"
-      }
-    },
     "node_modules/@types/acorn": {
       "version": "4.0.6",
       "resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz",
@@ -3148,14 +3102,14 @@
       "version": "15.7.13",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.13.tgz",
       "integrity": "sha512-hCZTSvwbzWGvhqxp/RqVqwU999pBf2vp7hzIjiYOsl8wqOmUxkQ6ddw1cV3l8811+kdUFus/q4d1Y3E3SyEifA==",
-      "devOptional": true,
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/react": {
       "version": "18.3.10",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.10.tgz",
       "integrity": "sha512-02sAAlBnP39JgXwkAq3PeU9DVaaGpZyF3MGcC0MKgQVkZor5IiiDAipVaxQHtDJAmO4GIy/rVBy/LzVj76Cyqg==",
-      "devOptional": true,
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/prop-types": "*",
@@ -6258,7 +6212,8 @@
     "node_modules/js-sha256": {
       "version": "0.10.1",
       "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.10.1.tgz",
-      "integrity": "sha512-5obBtsz9301ULlsgggLg542s/jqtddfOpV5KJc4hajc9JV8GeY2gZHSVpYBn4nWqAUTJ9v+xwtbJ1mIBgIH5Vw=="
+      "integrity": "sha512-5obBtsz9301ULlsgggLg542s/jqtddfOpV5KJc4hajc9JV8GeY2gZHSVpYBn4nWqAUTJ9v+xwtbJ1mIBgIH5Vw==",
+      "license": "MIT"
     },
     "node_modules/js-tokens": {
       "version": "4.0.0",
@@ -7828,7 +7783,8 @@
     "node_modules/moo": {
       "version": "0.5.2",
       "resolved": "https://registry.npmjs.org/moo/-/moo-0.5.2.tgz",
-      "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q=="
+      "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q==",
+      "license": "BSD-3-Clause"
     },
     "node_modules/morgan": {
       "version": "1.10.0",
@@ -12241,7 +12197,7 @@
       "version": "3.23.8",
       "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
       "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
-      "devOptional": true,
+      "dev": true,
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"

apps/monograph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notesnook/monograph",
-  "version": "1.2.4",
+  "version": "1.2.2",
   "private": true,
   "sideEffects": false,
   "type": "module",
@@ -15,8 +15,8 @@
     "@emotion/cache": "11.11.0",
     "@emotion/react": "11.11.1",
     "@emotion/server": "11.11.0",
-    "@lingui/core": "5.1.2",
-    "@lingui/react": "5.1.2",
+    "@lingui/core": "4.11.4",
+    "@lingui/react": "4.11.4",
     "@mdi/js": "^7.4.47",
     "@napi-rs/canvas": "0.1.59",
     "@notesnook/core": "file:../../packages/core",
@@ -64,5 +64,8 @@
     "vite-plugin-static-copy": "^2.1.0",
     "vite-tsconfig-paths": "^5.0.1",
     "wrangler": "3.78.11"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   }
 }

apps/theme-builder/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@notesnook/theme-builder",
   "description": "Your private note taking space",
-  "version": "1.3.0",
+  "version": "1.2.0",
   "private": true,
   "main": "./src/app.js",
   "homepage": "https://notesnook.com/",
@@ -12,25 +12,35 @@
     "@mdi/js": "^7.2.96",
     "@mdi/react": "^1.6.1",
     "@notesnook/common": "file:../../packages/common",
-    "@notesnook/intl": "file:../../packages/intl",
     "@notesnook/theme": "file:../../packages/theme",
     "@notesnook/web": "file:../web",
-    "@streetwriters/kysely": "^0.27.4",
     "@theme-ui/components": "^0.14.7",
     "@theme-ui/core": "^0.14.7",
     "@trpc/client": "10.45.2",
     "@types/react-dom": "^18.3.0",
     "clipboard-polyfill": "^4.0.0",
-    "dayjs": "1.11.13",
     "file-saver": "^2.0.5",
     "katex": "^0.16.2",
     "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "react-modal": "3.16.3",
-    "@lingui/core": "5.1.2"
+    "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "vite": "5.4.11"
+    "@babel/core": "^7.22.5",
+    "@types/babel__core": "^7.20.1",
+    "@types/file-saver": "^2.0.5",
+    "@types/react": "^18.2.39",
+    "@vitejs/plugin-react-swc": "^3.3.2",
+    "autoprefixer": "^10.4.14",
+    "buffer": "^6.0.3",
+    "chalk": "^4.1.0",
+    "happy-dom": "^8.9.0",
+    "rollup": "^3.27.0",
+    "rollup-plugin-visualizer": "^5.9.2",
+    "swc-plugin-react-remove-properties": "^0.1.4",
+    "vite": "^4.3.9",
+    "vite-plugin-env-compatible": "^1.1.1",
+    "vite-plugin-svgr": "^3.2.0",
+    "vitest": "^0.32.0"
   },
   "overrides": {
     "@theme-ui/components@>0": "0.14.7",

apps/theme-builder/src/index.css

@@ -1,13 +0,0 @@
-#root > .theme-scope-base {
-  display: flex;
-  height: 100%;
-}
-
-#app {
-  flex: 1;
-  height: unset;
-}
-
-#root > .theme-scope-base > :first-child:not(#menu-wrapper) {
-  flex: 1;
-}

apps/theme-builder/src/index.tsx

@@ -17,44 +17,60 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import "./index.css";
-import "@notesnook/web/src/polyfills";
-import "@notesnook/web/src/app.css";
-import { ThemeDark, ThemeLight, themeToCSS } from "@notesnook/theme";
-import Config from "@notesnook/web/src/utils/config";
-import { setI18nGlobal, Messages } from "@notesnook/intl";
-import { i18n } from "@lingui/core";
+import { init } from "@notesnook/web/src/bootstrap";
+import { createRoot } from "react-dom/client";
+import {
+  ErrorBoundary,
+  ErrorComponent
+} from "@notesnook/web/src/components/error-boundary";
+import { BaseThemeProvider } from "@notesnook/web/src/components/theme-provider";
 import { App } from "./app";
 
-const colorScheme = JSON.parse(
-  window.localStorage.getItem("colorScheme") || '"light"'
-);
-const root = document.querySelector("html");
-if (root) root.setAttribute("data-theme", colorScheme);
+renderApp();
 
-const theme =
-  colorScheme === "dark"
-    ? Config.get("theme:dark", ThemeDark)
-    : Config.get("theme:light", ThemeLight);
-const stylesheet = document.getElementById("theme-colors");
-if (theme) {
-  const css = themeToCSS(theme);
-  if (stylesheet) stylesheet.innerHTML = css;
-} else stylesheet?.remove();
+async function renderApp() {
+  const rootElement = document.getElementById("root");
+  if (!rootElement) return;
+  const root = createRoot(rootElement);
+  try {
+    const { component, props } = await init();
 
-const locale = import.meta.env.DEV
-  ? import("@notesnook/intl/locales/$pseudo-LOCALE.json")
-  : import("@notesnook/intl/locales/$en.json");
-locale.then(({ default: locale }) => {
-  i18n.load({
-    en: locale.messages as unknown as Messages
-  });
-  i18n.activate("en");
+    const { useKeyStore } = await import(
+      "@notesnook/web/src/interfaces/key-store"
+    );
+    await useKeyStore.getState().init();
 
-  performance.mark("import:root");
-  import("@notesnook/web/src/root.js").then(({ startApp }) => {
-    performance.mark("start:app");
-    startApp(<App />);
-  });
-});
-setI18nGlobal(i18n);
+    const { default: Component } = await component();
+    const { default: AppLock } = await import(
+      "@notesnook/web/src/views/app-lock"
+    );
+
+    root.render(
+      <ErrorBoundary>
+        <BaseThemeProvider
+          onRender={() => document.getElementById("splash")?.remove()}
+          sx={{
+            display: "flex",
+            "#app": { flex: 1, height: "unset" },
+            "& > :first-child:not(#menu-wrapper)": { flex: 1 },
+            height: "100%"
+          }}
+        >
+          <AppLock>
+            <Component route={props?.route || "login:email"} />
+          </AppLock>
+          <App />
+        </BaseThemeProvider>
+      </ErrorBoundary>
+    );
+  } catch (e) {
+    root.render(
+      <>
+        <ErrorComponent
+          error={e}
+          resetErrorBoundary={() => window.location.reload()}
+        />
+      </>
+    );
+  }
+}

apps/vericrypt/src/components/errors-list.tsx

@@ -26,7 +26,7 @@ type ErrorsListProps = {
 export function ErrorsList(props: ErrorsListProps) {
   return (
     <Accordion
-      title={`${props.errors.length} errors occurred`}
+      title={`${props.errors.length} errors occured`}
       sx={{ bg: "errorBg", borderRadius: "default", mt: 2 }}
       color="#E53935"
     >

apps/web/.gitignore

@@ -30,5 +30,4 @@ dist
 public/workbox
 scripts/secrets
 test-results
-.swc
-.wrangler
+.swc

apps/web/__e2e__/editor.test.ts

@@ -258,21 +258,6 @@ test("creating a new note and toggling read-only mode should not empty editor co
   expect(await notes.editor.getContent("text")).toBe(NOTE.content);
 });
 
-test("toggling read-only should hide undo & redo buttons", async ({ page }) => {
-  const app = new AppModel(page);
-  await app.goto();
-  const notes = await app.goToNotes();
-  const note = await notes.createNote(NOTE);
-
-  await notes.editor.undoButton.waitFor({ state: "visible" });
-  await notes.editor.redoButton.waitFor({ state: "visible" });
-  await note?.properties.readonly();
-
-  expect(await note?.properties.isReadonly()).toBeTruthy();
-  expect(notes.editor.undoButton).not.toBeVisible();
-  expect(notes.editor.redoButton).not.toBeVisible();
-});
-
 test("#1468 count words separated by newlines", async ({ page }) => {
   const app = new AppModel(page);
   await app.goto();
@@ -362,7 +347,7 @@ test("when autosave is disabled, creating a new note should save the note", asyn
   await notes.newNote();
 
   await note?.openNote();
-  // await expect(notes.editor.savedIcon).toBeVisible();
+  await expect(notes.editor.savedIcon).toBeVisible();
   expect(await notes.editor.getContent("text")).toBe(content.trim());
 });
 
@@ -400,7 +385,7 @@ test("control + alt + right arrow should go to next note", async ({ page }) => {
   });
 
   await note1?.openNote();
-  await note2?.openNote(true);
+  await note2?.openNote();
   await page.keyboard.press("Control+Alt+ArrowRight");
 
   expect(await notes.editor.getTitle()).toBe("Note 1");
@@ -428,7 +413,7 @@ test("control + alt + left arrow should go to previous note", async ({
   });
 
   await note1?.openNote();
-  await note2?.openNote(true);
+  await note2?.openNote();
   await page.keyboard.press("Control+Alt+ArrowLeft");
 
   expect(await notes.editor.getTitle()).toBe("Note 1");

apps/web/__e2e__/editor.test.ts-snapshots/readonly-edited-note-Chromium-darwin.txt

@@ -1 +1 @@
-An edit I madeThis is Test 1Test 1Test 1Test 1Test 1Test 1Test 1Test 1Test 1Test 1
+This is Test 1Test 1Test 1Test 1Test 1Test 1Test 1Test 1Test 1Test 1An edit I made

apps/web/__e2e__/models/app.model.ts

@@ -55,7 +55,7 @@ export class AppModel {
   }
 
   goBack() {
-    const goBackButton = this.page.locator(getTestId("route-go-back"));
+    const goBackButton = this.page.locator(getTestId("go-back"));
     return goBackButton.click();
   }
 

apps/web/__e2e__/models/base-item.model.ts

@@ -39,12 +39,10 @@ export class BaseItemModel {
     return await this.locator.evaluate((el) => el === document.activeElement);
   }
 
-  async click(options?: { middleClick?: boolean }) {
+  async click() {
     if (!(await this.locator.isVisible()))
       await this.locator.scrollIntoViewIfNeeded();
-    await this.locator.click({
-      button: options?.middleClick ? "middle" : "left"
-    });
+    await this.locator.click();
   }
 
   async getId() {

apps/web/__e2e__/models/editor.model.ts

@@ -36,13 +36,8 @@ export class EditorModel {
   private readonly dateEditedText: Locator;
   private readonly searchButton: Locator;
   private readonly tabsList: Locator;
-  private readonly goBackButton: Locator;
-  private readonly goForwardButton: Locator;
-  private readonly newTabButton: Locator;
   readonly savedIcon: Locator;
   readonly notSavedIcon: Locator;
-  readonly undoButton: Locator;
-  readonly redoButton: Locator;
 
   constructor(page: Page) {
     this.page = page;
@@ -64,11 +59,6 @@ export class EditorModel {
     this.savedIcon = page.locator(getTestId("editor-save-state-saved"));
     this.notSavedIcon = page.locator(getTestId("editor-save-state-notsaved"));
     this.tabsList = page.locator(getTestId("tabs"));
-    this.goBackButton = page.locator(getTestId("go-back"));
-    this.goForwardButton = page.locator(getTestId("go-forward"));
-    this.newTabButton = page.locator(getTestId("New tab"));
-    this.undoButton = page.locator(getTestId("Undo"));
-    this.redoButton = page.locator(getTestId("Redo"));
   }
 
   async waitForLoading(title?: string, content?: string) {
@@ -97,8 +87,8 @@ export class EditorModel {
     await this.searchButton.isDisabled();
     await this.page
       .locator(".active")
-      .locator(getTestId("editor-tag-input"))
-      .isDisabled();
+      .locator(getTestId("tags"))
+      .waitFor({ state: "hidden" });
     await this.dateEditedText.waitFor({ state: "hidden" });
     await this.wordCountText.waitFor();
     await this.waitForLoading("", "");
@@ -113,7 +103,7 @@ export class EditorModel {
 
   async isUnloaded() {
     return (
-      (await this.tagInput.isDisabled()) &&
+      (await this.tagInput.isHidden()) &&
       (await this.enterFullscreenButton.isHidden()) &&
       (await this.dateEditedText.isHidden())
     );
@@ -128,8 +118,7 @@ export class EditorModel {
   async typeTitle(text: string, delay = 0) {
     await this.editAndWait(async () => {
       await this.title.focus();
-      await this.title.selectText();
-      await this.title.press("ArrowRight");
+      await this.title.press("End");
       await this.title.type(text, { delay });
     });
   }
@@ -201,16 +190,6 @@ export class EditorModel {
     return tags;
   }
 
-  async removeTags(tags: string[]) {
-    for (const tag of tags) {
-      const item = this.tags
-        .filter({ hasText: tag })
-        .getByTitle("Remove")
-        .first();
-      await item.click();
-    }
-  }
-
   async getTitle() {
     return this.title.inputValue();
   }
@@ -264,26 +243,6 @@ export class EditorModel {
     }
   }
 
-  async getTabs() {
-    const tabs: TabItemModel[] = [];
-    for await (const item of iterateList(this.tabsList.locator(".tab"))) {
-      tabs.push(new TabItemModel(item, this.page));
-    }
-    return tabs;
-  }
-
-  async goBack() {
-    await this.goBackButton.click();
-  }
-
-  async goForward() {
-    await this.goForwardButton.click();
-  }
-
-  async newTab() {
-    await this.newTabButton.click();
-  }
-
   async attachImage() {
     await this.page
       .context()

apps/web/__e2e__/models/note-item.model.ts

@@ -38,8 +38,8 @@ export class NoteItemModel extends BaseItemModel {
     this.editor = new EditorModel(this.page);
   }
 
-  async openNote(openInNewTab?: boolean) {
-    await this.click({ middleClick: openInNewTab });
+  async openNote() {
+    await this.click();
     const title = await this.getTitle();
     await this.editor.waitForLoading(title);
   }

apps/web/__e2e__/models/note-properties.model.ts

@@ -211,11 +211,6 @@ export class NoteContextMenuModel extends BaseProperties {
     this.menu = new ContextMenuModel(page);
   }
 
-  async openInNewTab() {
-    await this.open();
-    await this.menu.clickOnItem("openinnewtab");
-  }
-
   async isColored(color: string): Promise<boolean> {
     await this.open();
     await this.menu.clickOnItem("colors");

apps/web/__e2e__/models/notebook-item.model.ts

@@ -98,9 +98,4 @@ export class NotebookItemModel extends BaseItemModel {
     await this.contextMenu.close();
     return state;
   }
-
-  async setAsDefault() {
-    await this.contextMenu.open(this.locator);
-    await new ToggleModel(this.page, "menu-button-set-as-default").on();
-  }
 }

apps/web/__e2e__/models/tab-item.model.ts

@@ -19,54 +19,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import { Locator, Page } from "@playwright/test";
 import { getTestId } from "../utils";
-import { ContextMenuModel } from "./context-menu.model";
 
 export class TabItemModel {
   private readonly closeButton: Locator;
-  readonly contextMenu: TabContextMenuModel;
-  readonly titleElement: Locator;
-
-  constructor(readonly locator: Locator, page: Page) {
+  constructor(private readonly locator: Locator, page: Page) {
     this.closeButton = locator.locator(getTestId("tab-close-button"));
-    this.contextMenu = new TabContextMenuModel(page, locator);
-    this.titleElement = locator.locator(getTestId("tab-title"));
   }
 
   async getId() {
     const testId = await this.locator.getAttribute("data-test-id");
     return testId?.replace("tab-", "");
   }
-
-  async click() {
-    return this.locator.click();
-  }
-
-  async title() {
-    return this.titleElement.textContent();
-  }
-
-  async isActive() {
-    const classList = await this.locator.getAttribute("class");
-    return !!classList?.includes("active");
-  }
-
   close() {
     return this.closeButton.click();
   }
 }
-
-class TabContextMenuModel {
-  private readonly menu: ContextMenuModel;
-  constructor(page: Page, private readonly tabLocator: Locator) {
-    this.menu = new ContextMenuModel(page);
-  }
-
-  async pin() {
-    await this.open();
-    await this.menu.clickOnItem("pin");
-  }
-
-  async open() {
-    await this.menu.open(this.tabLocator);
-  }
-}

apps/web/__e2e__/notebooks.test.ts

@@ -271,84 +271,3 @@ test(`sort notebooks`, async ({ page }, info) => {
     }
   }
 });
-
-test("when default notebook is set, created note in notes context should go to default notebook", async ({
-  page
-}) => {
-  const app = new AppModel(page);
-  await app.goto();
-  let notebooks = await app.goToNotebooks();
-  let notebook = await notebooks.createNotebook(NOTEBOOK);
-  await notebook?.setAsDefault();
-
-  const notes = await app.goToNotes();
-  await notes?.createNote(NOTE);
-  notebooks = await app.goToNotebooks();
-  notebook = await notebooks.findNotebook(NOTEBOOK);
-  const openedNotebook = await notebook?.openNotebook();
-
-  expect(await openedNotebook?.notes.findNote(NOTE)).toBeDefined();
-});
-
-test("when default notebook is set, created note in other notebook's context should not go to default notebook", async ({
-  page
-}) => {
-  const app = new AppModel(page);
-  await app.goto();
-  let notebooks = await app.goToNotebooks();
-  let notebook = await notebooks.createNotebook(NOTEBOOK);
-  await notebook?.setAsDefault();
-
-  const otherNotebook = await notebooks.createNotebook({
-    title: "Other Notebook"
-  });
-  const openedOtherNotebook = await otherNotebook?.openNotebook();
-  await openedOtherNotebook?.notes.createNote(NOTE);
-  notebooks = await app.goToNotebooks();
-  notebook = await notebooks.findNotebook(NOTEBOOK);
-  const openedNotebook = await notebook?.openNotebook();
-
-  expect(await openedNotebook?.notes.findNote(NOTE)).toBeUndefined();
-});
-
-test("when default notebook is set, created note in tags context should go to default notebook", async ({
-  page
-}) => {
-  const app = new AppModel(page);
-  await app.goto();
-  let notebooks = await app.goToNotebooks();
-  let notebook = await notebooks.createNotebook(NOTEBOOK);
-  await notebook?.setAsDefault();
-
-  const tags = await app.goToTags();
-  const tag = await tags.createItem({ title: "TestTag" });
-  const openedTag = await tag?.open();
-  await openedTag?.createNote(NOTE);
-  notebooks = await app.goToNotebooks();
-  notebook = await notebooks.findNotebook(NOTEBOOK);
-  const openedNotebook = await notebook?.openNotebook();
-
-  expect(await openedNotebook?.notes.findNote(NOTE)).toBeDefined();
-});
-
-test("when default notebook is set, created note in colors context should go to default notebook", async ({
-  page
-}) => {
-  const coloredNote = { title: "Red note", content: NOTE.content };
-  const app = new AppModel(page);
-  await app.goto();
-  let notebooks = await app.goToNotebooks();
-  let notebook = await notebooks.createNotebook(NOTEBOOK);
-  await notebook?.setAsDefault();
-
-  const notes = await app.goToNotes();
-  const note = await notes.createNote(NOTE);
-  await note?.contextMenu.newColor({ color: "#ff0000", title: "red" });
-  const color = await app.goToColor("red");
-  await color?.createNote(coloredNote);
-  notebooks = await app.goToNotebooks();
-  notebook = await notebooks.findNotebook(NOTEBOOK);
-  const openedNotebook = await notebook?.openNotebook();
-
-  expect(await openedNotebook?.notes.findNote(coloredNote)).toBeDefined();
-});

apps/web/__e2e__/notehistory.test.ts

@@ -17,11 +17,47 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { test, expect } from "@playwright/test";
-import { createHistorySession, PASSWORD } from "./utils";
+import { test, expect, Page } from "@playwright/test";
+import { AppModel } from "./models/app.model";
+import { NOTE, PASSWORD } from "./utils";
 
 test.setTimeout(60 * 1000);
 
+async function createSession(page: Page, locked = false) {
+  const app = new AppModel(page);
+  await app.goto();
+  const notes = await app.goToNotes();
+  let note = await notes.createNote(NOTE);
+
+  if (locked) {
+    await note?.contextMenu.lock(PASSWORD);
+    await note?.openLockedNote(PASSWORD);
+  }
+
+  const edits = ["Some edited text.", "Some more edited text."];
+  for (const edit of edits) {
+    await notes.editor.setContent(edit);
+
+    await page.waitForTimeout(600);
+
+    await page.reload().catch(console.error);
+    await notes.waitForItem(NOTE.title);
+    note = await notes.findNote(NOTE);
+    locked ? await note?.openLockedNote(PASSWORD) : await note?.openNote();
+  }
+  const contents = [
+    `${NOTE.content}${edits[0]}${edits[1]}`,
+    `${NOTE.content}${edits[0]}`
+  ];
+
+  return {
+    note,
+    notes,
+    app,
+    contents
+  };
+}
+
 const sessionTypes = ["locked", "unlocked"] as const;
 
 for (const type of sessionTypes) {
@@ -30,7 +66,7 @@ for (const type of sessionTypes) {
   test(`editing a note should create a new ${type} session in its session history`, async ({
     page
   }) => {
-    const { note } = await createHistorySession(page, isLocked);
+    const { note } = await createSession(page, isLocked);
 
     const history = await note?.properties.getSessionHistory();
     expect(history?.length).toBeGreaterThan(1);
@@ -45,7 +81,7 @@ for (const type of sessionTypes) {
   test(`switching ${type} sessions should change editor content`, async ({
     page
   }) => {
-    const { note, contents } = await createHistorySession(page, isLocked);
+    const { note, contents } = await createSession(page, isLocked);
 
     const history = await note?.properties.getSessionHistory();
     let preview = await history?.at(1)?.open();
@@ -55,7 +91,6 @@ for (const type of sessionTypes) {
       contents[1]
     );
     await note?.click();
-    if (type === "locked") await note?.openLockedNote(PASSWORD);
     await note?.properties.close();
     preview = await history?.at(0)?.open();
     if (type === "locked") await preview?.unlock(PASSWORD);
@@ -68,10 +103,7 @@ for (const type of sessionTypes) {
   test(`restoring a ${type} session should change note's content`, async ({
     page
   }) => {
-    const { note, notes, contents } = await createHistorySession(
-      page,
-      isLocked
-    );
+    const { note, notes, contents } = await createSession(page, isLocked);
     const history = await note?.properties.getSessionHistory();
     const preview = await history?.at(1)?.open();
     if (type === "locked") await preview?.unlock(PASSWORD);
@@ -83,3 +115,44 @@ for (const type of sessionTypes) {
     expect(await notes.editor.getContent("text")).toBe(contents[1]);
   });
 }
+// test("editing locked note should create locked history sessions", async ({
+//   page
+// }) => {
+//   const { note } = await createLockedSession(page);
+
+//   const history = await note?.properties.getSessionHistory();
+//   expect(history).toHaveLength(2);
+// for (const item of history || []) {
+//   expect(await item.isLocked()).toBeTruthy();
+// }
+// });
+
+// test("switching locked sessions should change editor content", async ({
+//   page
+// }) => {
+//   const { note, notes, contents } = await createLockedSession(page);
+
+//   const history = await note?.properties.getSessionHistory();
+//   await history?.at(1)?.previewLocked(PASSWORD);
+//   await notes.editor.waitForLoading(NOTE.title, contents[1]);
+//   const content1 = await notes.editor.getContent("text");
+
+//   await history?.at(0)?.previewLocked(PASSWORD);
+//   await notes.editor.waitForLoading(NOTE.title, contents[0]);
+//   const content0 = await notes.editor.getContent("text");
+
+//   expect(content1).toBe(contents[1]);
+//   expect(content0).toBe(contents[0]);
+// });
+
+// test("restore a locked session", async ({ page }) => {
+//   const { note, notes, contents } = await createLockedSession(page);
+//   const history = await note?.properties.getSessionHistory();
+//   await history?.at(1)?.previewLocked(PASSWORD);
+//   await notes.editor.waitForLoading(NOTE.title, contents[1]);
+
+//   await notes.editor.restoreSession();
+
+//   const content = await notes.editor.getContent("text");
+//   expect(content).toBe(contents[1]);
+// });

apps/web/__e2e__/sync.test.ts

@@ -20,9 +20,6 @@ import { test, Browser, expect } from "@playwright/test";
 import { AppModel } from "./models/app.model";
 import { USER } from "./utils";
 
-// run this test file sequentially
-test.describe.configure({ mode: "serial" });
-
 async function createDevice(browser: Browser) {
   // Create two isolated browser contexts
   const context = await browser.newContext();
@@ -51,13 +48,13 @@ async function actAndSync<T>(
   return results.slice(0, actions.length) as T[];
 }
 
-test(`content edits in a note opened on 2 devices in multiple tabs should sync in real-time`, async ({
+const NOTE = {
+  title: `Note ${makeid(20)}`
+};
+
+test(`edits in a note opened on 2 devices should sync in real-time`, async ({
   browser
 }, info) => {
-  const NOTE = {
-    title: `Note ${makeid(20)}`
-  };
-
   info.setTimeout(70 * 1000);
   const newContent = makeid(24).repeat(2);
 
@@ -74,7 +71,6 @@ test(`content edits in a note opened on 2 devices in multiple tabs should sync i
   )[0];
   const noteA = await notesA.findNote(NOTE);
   await Promise.all([noteA, noteB].map((note) => note?.openNote()));
-  await noteA?.openNote(true);
 
   if ((await notesB.editor.getContent("text")) !== "")
     await actAndSync([deviceA, deviceB], notesB.editor.clear());
@@ -86,52 +82,6 @@ test(`content edits in a note opened on 2 devices in multiple tabs should sync i
   expect(noteB).toBeDefined();
   await expect(notesA.editor.content).toHaveText(newContent);
   await expect(notesB.editor.content).toHaveText(newContent);
-  const tabsA = await notesA.editor.getTabs();
-  await tabsA[0].click();
-  await expect(notesA.editor.content).toHaveText(newContent);
-
-  await (await deviceA.goToSettings())?.logout();
-  await (await deviceB.goToSettings())?.logout();
-});
-
-test(`title edits in a note opened on 2 devices in multiple tabs should sync in real-time`, async ({
-  browser
-}, info) => {
-  const NOTE = {
-    title: `Note ${makeid(20)}`
-  };
-
-  info.setTimeout(70 * 1000);
-  const newContent = makeid(24).repeat(2);
-
-  const [deviceA, deviceB] = await Promise.all([
-    createDevice(browser),
-    createDevice(browser)
-  ]);
-
-  const [notesA, notesB] = await Promise.all(
-    [deviceA, deviceB].map((d) => d.goToNotes())
-  );
-  const noteB = (
-    await actAndSync([deviceA, deviceB], notesB.createNote(NOTE))
-  )[0];
-  const noteA = await notesA.findNote(NOTE);
-  await Promise.all([noteA, noteB].map((note) => note?.openNote()));
-  await noteA?.openNote(true);
-
-  if ((await notesB.editor.getContent("text")) !== "")
-    await actAndSync([deviceA, deviceB], notesB.editor.clear());
-  await expect(notesA.editor.content).toBeEmpty();
-  await expect(notesB.editor.content).toBeEmpty();
-  await actAndSync([deviceA, deviceB], notesB.editor.setTitle(newContent));
-
-  expect(noteA).toBeDefined();
-  expect(noteB).toBeDefined();
-  expect(await notesA.editor.getTitle()).toBe(newContent);
-  expect(await notesB.editor.getTitle()).toBe(newContent);
-  const tabsA = await notesA.editor.getTabs();
-  await tabsA[0].click();
-  expect(await notesA.editor.getTitle()).toBe(newContent);
 
   await (await deviceA.goToSettings())?.logout();
   await (await deviceB.goToSettings())?.logout();