mobile: set default widget size

.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/android.publish.yml

@@ -4,7 +4,7 @@ on: workflow_dispatch
 
 jobs:
   build:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     timeout-minutes: 40
     env:
       CMAKE_C_COMPILER_LAUNCHER: ccache

.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,28 +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/>.
 */
 
-import { PropsWithChildren } from "react";
-import { HTMLElementProps, IPaneConfigs } from "./types";
+import { _electron as electron } from "playwright";
 
-export default function Pane({
-  paneRef,
-  children,
-  style,
-  className,
-  role,
-  title,
-  id
-}: PropsWithChildren<HTMLElementProps & IPaneConfigs>) {
-  return (
-    <div
-      id={id}
-      ref={paneRef}
-      role={role}
-      title={title}
-      className={className}
-      style={style}
-    >
-      {children}
-    </div>
-  );
+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.23",
   "appAppleId": "1544027013",
   "private": true,
   "main": "./dist/cjs/index.js",
@@ -25,18 +25,18 @@
   "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",
+    "sqlite-better-trigram": "^0.0.2",
     "typed-emitter": "^2.1.0",
     "yargs": "^17.7.2",
-    "zod": "3.23.8"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@streetwriters/kysely": "^0.27.4",
@@ -45,15 +45,15 @@
     "chokidar": "^4.0.1",
     "electron": "^31.7.4",
     "electron-builder": "^25.1.8",
-    "esbuild": "0.21.5",
+    "esbuild": "^0.24.0",
     "node-abi": "^3.68.0",
     "node-gyp-build": "^4.8.2",
     "playwright": "^1.48.2",
     "prebuildify": "^6.0.1",
-    "slugify": "1.6.6",
+    "slugify": "^1.6.6",
     "tree-kill": "^1.2.2",
     "undici": "^6.19.8",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.5"
   },
   "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,16 +29,14 @@ 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(
-    "npx nx build:desktop @notesnook/web",
+    "yarn nx build:desktop @notesnook/web",
     path.join(__dirname, "..", "..", "..")
   );
 }
@@ -46,31 +44,25 @@ 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 --x64`);
   if (process.platform === "win32") {
     await exec(`.\\output\\win-unpacked\\Notesnook.exe`);
   } else if (process.platform === "darwin") {
-    if (process.arch === "arm64")
-      await exec(`./output/mac-arm64/Notesnook.app/Contents/MacOS/Notesnook`);
-    else await exec(`./output/mac/Notesnook.app/Contents/MacOS/Notesnook`);
+    await exec(`./output/mac/Notesnook.app/Contents/MacOS/Notesnook`);
   } else {
     await exec(`./output/linux-unpacked/Notesnook`);
   }

apps/desktop/scripts/dev.mjs

@@ -70,8 +70,8 @@ async function onChange(first) {
 
   if (first) {
     await spawnAndWaitUntil(
-      ["npm", "run", "start:desktop"],
-      path.join(__dirname, "..", "..", "web"),
+      ["yarn", "nx", "start:desktop", "@notesnook/web"],
+      path.join(__dirname, "..", "..", ".."),
       (data) => data.includes("Network: use --host to expose")
     );
   }

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

@@ -32,7 +32,6 @@ import { withErrorBoundry } from "./components/exception-handler";
 import GlobalSafeAreaProvider from "./components/globalsafearea";
 import { useAppEvents } from "./hooks/use-app-events";
 import { ApplicationHolder } from "./navigation";
-import { NotePreviewConfigure } from "./screens/note-preview-configure";
 import { themeTrpcClient } from "./screens/settings/theme-selector";
 import Notifications from "./services/notifications";
 import SettingsService from "./services/settings";
@@ -48,7 +47,7 @@ if (appLockEnabled || appLockMode !== "none") {
   useUserStore.getState().lockApp(true);
 }
 
-const App = (props: { configureMode: "note-preview" }) => {
+const App = () => {
   useAppEvents();
   //@ts-ignore
   globalThis["IS_MAIN_APP_RUNNING"] = true;
@@ -62,7 +61,6 @@ const App = (props: { configureMode: "note-preview" }) => {
       TipManager.init();
     }, 100);
   }, []);
-
   return (
     <View
       style={{
@@ -92,11 +90,7 @@ const App = (props: { configureMode: "note-preview" }) => {
           width: "100%"
         }}
       >
-        {props.configureMode === "note-preview" ? (
-          <NotePreviewConfigure />
-        ) : (
-          <ApplicationHolder />
-        )}
+        <ApplicationHolder />
       </GestureHandlerRootView>
       <AppLockedOverlay />
     </View>
@@ -109,8 +103,8 @@ let currTheme =
     : SettingsService.getProperty("lighTheme");
 useThemeEngineStore.getState().setTheme(currTheme);
 
-export const withTheme = (Element: (props: any) => JSX.Element) => {
-  return function AppWithThemeProvider(props: any) {
+export const withTheme = (Element: () => JSX.Element) => {
+  return function AppWithThemeProvider() {
     const [colorScheme, darkTheme, lightTheme] = useThemeStore((state) => [
       state.colorScheme,
       state.darkTheme,
@@ -129,14 +123,13 @@ export const withTheme = (Element: (props: any) => JSX.Element) => {
           })
           .then((theme) => {
             if (theme) {
+              console.log(theme.version, "theme updated");
               theme.colorScheme === "dark"
                 ? useThemeStore.getState().setDarkTheme(theme)
                 : useThemeStore.getState().setLightTheme(theme);
             }
           })
-          .catch(() => {
-            /* empty */
-          });
+          .catch(console.log);
       }, 1000);
       // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
@@ -151,7 +144,7 @@ export const withTheme = (Element: (props: any) => JSX.Element) => {
 
     return (
       <I18nProvider i18n={i18n}>
-        <Element {...props} />
+        <Element />
       </I18nProvider>
     );
   };

apps/mobile/app/common/database/encryption.ts

@@ -126,6 +126,7 @@ export async function setAppLockVerificationCipher(appLockPassword: string) {
     DatabaseLogger.info("setAppLockVerificationCipher");
   } catch (e) {
     DatabaseLogger.error(e);
+    console.log(e);
   }
 }
 
@@ -158,77 +159,79 @@ export function clearDatabaseKey() {
 
 export async function getDatabaseKey(appLockPassword?: string) {
   if (DB_KEY) return DB_KEY;
-  if (appLockPassword) {
-    const databaseKeyCipher: Cipher = CipherStorage.getMap("databaseKeyCipher");
-    const databaseKey = await decrypt(
-      {
-        password: appLockPassword
-      },
-      databaseKeyCipher
-    );
-    DatabaseLogger.info("Getting database key from cipher");
-    DB_KEY = databaseKey;
-  }
+  try {
+    if (appLockPassword) {
+      const databaseKeyCipher: Cipher =
+        CipherStorage.getMap("databaseKeyCipher");
+      const databaseKey = await decrypt(
+        {
+          password: appLockPassword
+        },
+        databaseKeyCipher
+      );
+      DatabaseLogger.info("Getting database key from cipher");
+      DB_KEY = databaseKey;
+    }
 
-  if (!DB_KEY) {
-    const hasKey = await Keychain.hasInternetCredentials(KEYCHAIN_SERVER_DBKEY);
-    if (hasKey) {
-      const credentials = await Keychain.getInternetCredentials(
+    if (!DB_KEY) {
+      const hasKey = await Keychain.hasInternetCredentials(
         KEYCHAIN_SERVER_DBKEY
       );
+      if (hasKey) {
+        const credentials = await Keychain.getInternetCredentials(
+          KEYCHAIN_SERVER_DBKEY
+        );
 
-      DatabaseLogger.info("Getting database key from Keychain");
-      DB_KEY = (credentials as Keychain.UserCredentials).password;
+        DatabaseLogger.info("Getting database key from Keychain");
+        DB_KEY = (credentials as Keychain.UserCredentials).password;
+      }
     }
-  }
 
-  if (!DB_KEY) {
-    DatabaseLogger.info("Generating new database key");
-    const password = generatePassword();
-    const derivedDatabaseKey = await Sodium.deriveKey(
-      password,
-      NOTESNOOK_DB_KEY_SALT
-    );
+    if (!DB_KEY) {
+      DatabaseLogger.info("Generating new database key");
+      const password = generatePassword();
+      const derivedDatabaseKey = await Sodium.deriveKey(
+        password,
+        NOTESNOOK_DB_KEY_SALT
+      );
 
-    DB_KEY = derivedDatabaseKey.key as string;
+      DB_KEY = derivedDatabaseKey.key as string;
 
-    await Keychain.setInternetCredentials(
-      KEYCHAIN_SERVER_DBKEY,
-      "notesnook",
-      DB_KEY,
-      KEYSTORE_CONFIG
-    );
-  }
-
-  if (await Keychain.hasInternetCredentials("notesnook")) {
-    const userKeyCredentials = await Keychain.getInternetCredentials(
-      "notesnook"
-    );
-
-    if (userKeyCredentials) {
-      const userKeyCipher: Cipher = (await encrypt(
-        {
-          key: DB_KEY,
-          salt: NOTESNOOK_DB_KEY_SALT
-        },
-        userKeyCredentials.password
-      )) as Cipher;
-      // Store encrypted user key in MMKV
-      MMKV.setMap(USER_KEY_CIPHER, userKeyCipher);
-      await Keychain.resetInternetCredentials("notesnook");
+      await Keychain.setInternetCredentials(
+        KEYCHAIN_SERVER_DBKEY,
+        "notesnook",
+        DB_KEY,
+        KEYSTORE_CONFIG
+      );
     }
-    DatabaseLogger.info("Migrated user credentials to cipher storage");
-  }
 
-  if (!DB_KEY) {
-    throw new Error(
-      `Failed to get database key, ${await Keychain.hasInternetCredentials(
-        KEYCHAIN_SERVER_DBKEY
-      )}`
-    );
-  }
+    if (await Keychain.hasInternetCredentials("notesnook")) {
+      const userKeyCredentials = await Keychain.getInternetCredentials(
+        "notesnook"
+      );
 
-  return DB_KEY;
+      if (userKeyCredentials) {
+        const userKeyCipher: Cipher = (await encrypt(
+          {
+            key: DB_KEY,
+            salt: NOTESNOOK_DB_KEY_SALT
+          },
+          userKeyCredentials.password
+        )) as Cipher;
+        // Store encrypted user key in MMKV
+        MMKV.setMap(USER_KEY_CIPHER, userKeyCipher);
+        await Keychain.resetInternetCredentials("notesnook");
+      }
+      DatabaseLogger.info("Migrated user credentials to cipher storage");
+    }
+
+    return DB_KEY;
+  } catch (e) {
+    ToastManager.error(e as Error, "Error getting database key");
+    console.log(e, "error");
+    DatabaseLogger.error(e);
+    return null;
+  }
 }
 
 export async function deriveCryptoKeyFallback(data: SerializedKey) {
@@ -309,6 +312,7 @@ export async function getCryptoKey() {
 
     return key;
   } catch (e) {
+    console.log("getCryptoKey", e);
     DatabaseLogger.error(e);
   }
 }

apps/mobile/app/common/database/index.ts

@@ -39,6 +39,8 @@ export async function setupDatabase(password?: string) {
   const key = await getDatabaseKey(password);
   if (!key) throw new Error(strings.databaseSetupFailed());
 
+  console.log("Opening database with key:", !!key);
+
   database.host({
     API_HOST: "https://api.notesnook.com",
     AUTH_HOST: "https://auth.streetwriters.co",

apps/mobile/app/common/filesystem/compress.js

@@ -27,9 +27,13 @@ import RNFetchBlob from "react-native-blob-util";
  */
 export async function compressToBase64(path, type) {
   const { width: screenWidth, scale } = Dimensions.get("window");
-
+  console.log("COMPRESSING TO BASE64...");
   return new Promise((resolve) => {
+    console.log(path, "image path...");
+
     Image.getSize(path, async (width) => {
+      console.log("image width", width);
+
       const response = await ImageResizer.createResizedImage(
         path,
         screenWidth * scale,
@@ -51,12 +55,10 @@ export async function compressToBase64(path, type) {
           : response.uri,
         "base64"
       );
-      RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(() => {
-        /* empty */
-      });
-      RNFetchBlob.fs.unlink(response.uri.replace("file://", "")).catch(() => {
-        /* empty */
-      });
+      RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(console.log);
+      RNFetchBlob.fs
+        .unlink(response.uri.replace("file://", ""))
+        .catch(console.log);
 
       resolve(base64);
     });
@@ -78,8 +80,6 @@ export async function compressToFile(path, type) {
       onlyScaleDown: true
     }
   );
-  RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(() => {
-    /* empty */
-  });
+  RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(console.log);
   return response.uri;
 }

apps/mobile/app/common/filesystem/download-attachment.tsx

@@ -83,9 +83,7 @@ export async function downloadAttachments(attachmentIds: string[]) {
 
   const isCancelled = () => {
     if (useAttachmentStore.getState().downloading?.[groupId]?.canceled) {
-      RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
-        /* empty */
-      });
+      RNFetchBlob.fs.unlink(zipSourceFolder).catch(console.log);
       useAttachmentStore.getState().setDownloading({
         groupId,
         current: 0,
@@ -190,13 +188,9 @@ export async function downloadAttachments(attachmentIds: string[]) {
     ToastManager.error(e as Error, "Error zipping attachments");
   }
   // Remove source & zip file from cache.
-  RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
-    /* empty */
-  });
+  RNFetchBlob.fs.unlink(zipSourceFolder).catch(console.log);
   if (Platform.OS === "android") {
-    RNFetchBlob.fs.unlink(zipOutputFile).catch(() => {
-      /* empty */
-    });
+    RNFetchBlob.fs.unlink(zipOutputFile).catch(console.log);
   }
 }
 
@@ -327,14 +321,10 @@ export default async function downloadAttachment(
     if (attachment.dateUploaded) {
       RNFetchBlob.fs
         .unlink(RNFetchBlob.fs.dirs.CacheDir + `/${attachment.hash}`)
-        .catch(() => {
-          /* empty */
-        });
+        .catch(console.log);
       RNFetchBlob.fs
         .unlink(RNFetchBlob.fs.dirs.CacheDir + `/${attachment.hash}_dcache`)
-        .catch(() => {
-          /* empty */
-        });
+        .catch(console.log);
     }
 
     useAttachmentStore.getState().setDownloading({

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

@@ -123,9 +123,7 @@ export async function downloadFile(
     cancelToken.cancel = async (reason) => {
       useAttachmentStore.getState().remove(filename);
       request.cancel();
-      RNFetchBlob.fs.unlink(tempFilePath).catch(() => {
-        /* empty */
-      });
+      RNFetchBlob.fs.unlink(tempFilePath).catch(console.log);
       DatabaseLogger.log(`Download cancelled: ${reason} ${filename}`);
     };
 
@@ -144,9 +142,7 @@ export async function downloadFile(
     useAttachmentStore.getState().remove(filename);
 
     if (await exists(originalFilePath)) {
-      await RNFetchBlob.fs.unlink(originalFilePath).catch(() => {
-        /* empty */
-      });
+      await RNFetchBlob.fs.unlink(originalFilePath).catch(console.log);
     }
 
     await RNFetchBlob.fs.mv(tempFilePath, originalFilePath);
@@ -173,12 +169,8 @@ export async function downloadFile(
     }
 
     useAttachmentStore.getState().remove(filename);
-    RNFetchBlob.fs.unlink(tempFilePath).catch(() => {
-      /* empty */
-    });
-    RNFetchBlob.fs.unlink(originalFilePath).catch(() => {
-      /* empty */
-    });
+    RNFetchBlob.fs.unlink(tempFilePath).catch(console.log);
+    RNFetchBlob.fs.unlink(originalFilePath).catch(console.log);
     DatabaseLogger.error(e, "Download failed: ", {
       url
     });
@@ -196,7 +188,7 @@ export async function checkAttachment(hash: string) {
 
   try {
     const size = await getUploadedFileSize(hash);
-
+    console.log("File Size", size);
     if (size === -1) return { success: true };
 
     if (size === 0)

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

@@ -60,9 +60,7 @@ export async function readEncrypted<TOutputFormat extends DataFormat>(
 
     return output as Output<TOutputFormat>;
   } catch (e) {
-    RNFetchBlob.fs.unlink(path).catch(() => {
-      /* empty */
-    });
+    RNFetchBlob.fs.unlink(path).catch(console.log);
     DatabaseLogger.error(e);
   }
 }
@@ -92,9 +90,8 @@ export async function writeEncryptedBase64(
     type: "url"
   });
 
-  RNFetchBlob.fs.unlink(filepath).catch(() => {
-    /* empty */
-  });
+  RNFetchBlob.fs.unlink(filepath).catch(console.log);
+  console.log("encrypted file output: ", output);
 
   return {
     ...output,
@@ -109,9 +106,7 @@ export async function deleteFile(
   await createCacheDir();
   const localFilePath = cacheDir + `/${filename}`;
   if (!requestOptions) {
-    RNFetchBlob.fs.unlink(localFilePath).catch(() => {
-      /* empty */
-    });
+    RNFetchBlob.fs.unlink(localFilePath).catch(console.log);
     return true;
   }
 
@@ -122,9 +117,7 @@ export async function deleteFile(
     const status = response.info().status;
     const ok = status >= 200 && status < 300;
     if (ok) {
-      RNFetchBlob.fs.unlink(localFilePath).catch(() => {
-        /* empty */
-      });
+      RNFetchBlob.fs.unlink(localFilePath).catch(console.log);
     }
     return ok;
   } catch (e) {
@@ -141,14 +134,10 @@ export async function clearFileStorage() {
     const oldCache = await RNFetchBlob.fs.ls(cacheDirOld);
 
     for (const file of files) {
-      await RNFetchBlob.fs.unlink(cacheDir + `/${file}`).catch(() => {
-        /* empty */
-      });
+      await RNFetchBlob.fs.unlink(cacheDir + `/${file}`).catch(console.log);
     }
     for (const file of oldCache) {
-      await RNFetchBlob.fs.unlink(cacheDirOld + `/${file}`).catch(() => {
-        /* empty */
-      });
+      await RNFetchBlob.fs.unlink(cacheDirOld + `/${file}`).catch(console.log);
     }
   } catch (e) {
     DatabaseLogger.error(e, "clearFileStorage");
@@ -172,19 +161,20 @@ export async function migrateFilesFromCache() {
     const migratedFilesPath = cacheDir + "/.migrated_1";
     const migrated = await RNFetchBlob.fs.exists(migratedFilesPath);
     if (migrated) {
+      console.log("Files migrated already");
       return;
     }
 
     const files = await RNFetchBlob.fs.ls(cacheDir);
+    console.log("Files to migrate:", files.join(","));
 
     const oldCache = await RNFetchBlob.fs.ls(cacheDirOld);
     for (const file of oldCache) {
       if (file.startsWith("org.") || file.startsWith("com.")) continue;
       RNFetchBlob.fs
         .mv(cacheDirOld + `/${file}`, cacheDir + `/${file}`)
-        .catch(() => {
-          /* empty */
-        });
+        .catch(console.log);
+      console.log("Moved", file);
     }
     await RNFetchBlob.fs.createFile(migratedFilesPath, "1", "utf8");
   } catch (e) {
@@ -193,17 +183,13 @@ export async function migrateFilesFromCache() {
 }
 
 export async function clearCache() {
-  await RNFetchBlob.fs.unlink(cacheDir).catch(() => {
-    /* empty */
-  });
+  await RNFetchBlob.fs.unlink(cacheDir).catch(console.log);
   await createCacheDir();
   eSendEvent("cache-cleared");
 }
 
 export async function deleteCacheFileByPath(path: string) {
-  await RNFetchBlob.fs.unlink(path).catch(() => {
-    /* empty */
-  });
+  await RNFetchBlob.fs.unlink(path).catch(console.log);
 }
 
 export async function deleteCacheFileByName(name: string) {
@@ -212,45 +198,19 @@ export async function deleteCacheFileByName(name: string) {
       ? await (RNFetchBlob.fs as any).pathForAppGroup(IOS_APPGROUPID)
       : null;
   const appGroupPath = `${iosAppGroup}/${name}`;
-  await RNFetchBlob.fs.unlink(appGroupPath).catch(() => {
-    /* empty */
-  });
-  await RNFetchBlob.fs.unlink(`${cacheDir}/${name}`).catch(() => {
-    /* empty */
-  });
+  await RNFetchBlob.fs.unlink(appGroupPath).catch(console.log);
+  await RNFetchBlob.fs.unlink(`${cacheDir}/${name}`).catch(console.log);
 }
 
 export async function deleteDCacheFiles() {
   const files = await RNFetchBlob.fs.ls(cacheDir);
   for (const file of files) {
-    if (file.includes("_dcache") || file.startsWith("NN_")) {
-      await RNFetchBlob.fs.unlink(file).catch(() => {
-        /* empty */
-      });
+    if (file.includes("_dcache")) {
+      await RNFetchBlob.fs.unlink(file).catch(console.log);
     }
   }
 }
 
-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}`;
 
@@ -285,9 +245,7 @@ export async function exists(filename: string) {
       );
       RNFetchBlob.fs
         .unlink(existsInAppGroup ? appGroupPath : path)
-        .catch(() => {
-          /* empty */
-        });
+        .catch(console.log);
       return false;
     }
 
@@ -323,7 +281,7 @@ export async function getCacheSize() {
   await createCacheDir();
   const stat = await RNFetchBlob.fs.lstat(`file://` + cacheDir);
   let total = 0;
-
+  console.log("Total files", stat.length);
   stat.forEach((file) => {
     total += parseInt(file.size as unknown as string);
   });

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/common/logger/index.ts

@@ -17,7 +17,9 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-function info(context: string, ...logs: unknown[]) {}
+function info(context: string, ...logs: unknown[]) {
+  console.log(`${new Date().toLocaleDateString()}::info::${context}:`, ...logs);
+}
 
 function error(context: string, ...logs: unknown[]) {
   console.log(

apps/mobile/app/components/announcements/cta.js

@@ -41,9 +41,7 @@ export const Cta = ({ actions, style = {}, color, inline }) => {
       await sleep(500);
     }
     if (item.type === "link") {
-      Linking.openURL(item.data).catch(() => {
-        /* empty */
-      });
+      Linking.openURL(item.data).catch(console.log);
     } else if (item.type === "promo") {
       presentSheet({
         component: (

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/attachments/index.tsx

@@ -528,9 +528,7 @@ export const AttachmentDialog = ({
                         setAttachments(results);
                         setLoading(false);
                       })
-                      .catch(() => {
-                        /* empty */
-                      });
+                      .catch(console.log);
                   }}
                 />
               )

apps/mobile/app/components/auth/change-password.js

@@ -88,6 +88,7 @@ export const ChangePassword = () => {
       await sleep(300);
       eSendEvent(eOpenRecoveryKeyDialog);
     } catch (e) {
+      console.log(e.stack);
       setLoading(false);
       ToastManager.show({
         heading: strings.passwordChangeFailed(),

apps/mobile/app/components/auth/use-login.js

@@ -70,7 +70,7 @@ export const useLogin = (onFinishLogin, sessionExpired = false) => {
       switch (step) {
         case LoginSteps.emailAuth: {
           const mfaInfo = await db.user.authenticateEmail(email.current);
-
+          console.log("email auth", mfaInfo);
           if (mfaInfo) {
             TwoFactorVerification.present(
               async (mfa, callback) => {

apps/mobile/app/components/dialog/base-dialog.tsx

@@ -75,9 +75,9 @@ const BaseDialog = ({
   background
 }: BaseDialogProps) => {
   const floating = useIsFloatingKeyboard();
+  const appState = useAppState();
   const lockEvents = useRef(false);
   const [internalVisible, setIntervalVisible] = useState(true);
-  const locked = useUserStore((state) => state.appLocked);
 
   useEffect(() => {
     return () => {
@@ -86,20 +86,26 @@ const BaseDialog = ({
   }, []);
 
   useEffect(() => {
-    if (locked) {
-      setIntervalVisible(false);
-      lockEvents.current = true;
-      const unsub = useUserStore.subscribe((state) => {
-        if (!state.appLocked) {
-          setIntervalVisible(true);
-          unsub();
-          setTimeout(() => {
-            lockEvents.current = false;
+    if (useUserStore.getState().disableAppLockRequests) return;
+
+    if (SettingsService.canLockAppInBackground()) {
+      if (appState === "background") {
+        setIntervalVisible(false);
+        if (useUserStore.getState().appLocked) {
+          lockEvents.current = true;
+          const unsub = useUserStore.subscribe((state) => {
+            if (!state.appLocked) {
+              setIntervalVisible(true);
+              unsub();
+              setTimeout(() => {
+                lockEvents.current = false;
+              });
+            }
           });
         }
-      });
+      }
     }
-  }, [locked]);
+  }, [appState]);
 
   const Wrapper = useSafeArea ? SafeAreaView : View;
 

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/dialogs/attach-image-dialog/index.tsx

@@ -180,7 +180,7 @@ AttachImage.present = (response: ImageType[], context?: string) => {
           close={close}
           onAttach={(result) => {
             resolved = true;
-
+            console.log("closing");
             resolve(result);
             close?.();
           }}

apps/mobile/app/components/dialogs/pdf-preview/index.js

@@ -307,7 +307,9 @@ const PDFPreview = () => {
                     password={password}
                     maxScale={6}
                     onError={onError}
-                    onPressLink={(uri) => {}}
+                    onPressLink={(uri) => {
+                      console.log(`Link pressed: ${uri}`);
+                    }}
                     style={{
                       flex: 1,
                       width: width,

apps/mobile/app/components/dialogs/progress/index.tsx

@@ -62,7 +62,7 @@ export default function Progress() {
       eSubscribeEvent(PROGRESS_EVENTS.start, (options: ProgressOptions) => {
         setProgress(options.progress);
         cancelCallback.current = options.cancelCallback;
-
+        console.log("options", options.fillBackground);
         setData({
           title: options.title,
           paragraph: options.paragraph,

apps/mobile/app/components/dialogs/vault/index.js

@@ -336,7 +336,7 @@ export class VaultDialog extends Component {
             );
           });
         }
-
+        console.log("VAULT UPDATED EVENT");
         eSendEvent("vaultUpdated");
         this.setState({
           loading: false
@@ -406,6 +406,7 @@ export class VaultDialog extends Component {
     } else {
       await db.vault.add(this.state.note.id);
 
+      console.log("update note event...");
       eSendEvent(eUpdateNoteInEditor, this.state.note, true);
 
       this.close();
@@ -542,6 +543,7 @@ export class VaultDialog extends Component {
         this.close();
       })
       .catch((e) => {
+        console.log("Error", e);
         this._takeErrorAction(e);
       });
   }

apps/mobile/app/components/exception-handler/index.tsx

@@ -78,10 +78,10 @@ class ExceptionHandler extends React.Component<{
 }
 
 export const withErrorBoundry = (Element: React.ElementType, name: string) => {
-  return function ErrorBoundary(props: any) {
+  return function ErrorBoundary() {
     return (
       <ExceptionHandler component={name}>
-        <Element {...props} />
+        <Element />
       </ExceptionHandler>
     );
   };

apps/mobile/app/components/header/index.tsx

@@ -54,7 +54,7 @@ export const Header = ({
   onSearch
 }: {
   onLeftMenuButtonPress?: () => void;
-  renderedInRoute?: RouteName;
+  renderedInRoute: RouteName;
   id?: string;
   title: string;
   headerRightButtons?: HeaderRightButton[];

apps/mobile/app/components/header/right-menus.tsx

@@ -41,7 +41,7 @@ export const RightMenus = ({
   onSearch
 }: {
   headerRightButtons?: HeaderRightButton[];
-  renderedInRoute?: RouteName;
+  renderedInRoute: RouteName;
   id?: string;
   onPressDefaultRightButton?: () => void;
   search?: boolean;

apps/mobile/app/components/header/title.tsx

@@ -41,7 +41,7 @@ export const Title = ({
   isHiddenOnRender?: boolean;
   accentColor?: string;
   isBeta?: boolean;
-  renderedInRoute?: string;
+  renderedInRoute: string;
   id?: string;
 }) => {
   const { colors } = useThemeColors();

apps/mobile/app/components/image-preview/index.tsx

@@ -18,7 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import Sodium from "@ammarahmed/react-native-sodium";
-import { DataURL, getFileNameWithExtension } from "@notesnook/core";
+import { DataURL } from "@notesnook/core";
 import type { ImageAttributes } from "@notesnook/editor";
 import { useThemeColors } from "@notesnook/theme";
 import React, { useEffect, useRef, useState } from "react";
@@ -34,11 +34,6 @@ import {
 import BaseDialog from "../dialog/base-dialog";
 import { IconButton } from "../ui/icon-button";
 import { ProgressBarComponent } from "../ui/svg/lazy";
-import RNFetchBlob from "react-native-blob-util";
-import Share from "react-native-share";
-import useGlobalSafeAreaInsets from "../../hooks/use-global-safe-area-insets";
-import { useSettingStore } from "../../stores/use-setting-store";
-
 const ImagePreview = () => {
   const { colors } = useThemeColors("dialog");
 
@@ -46,8 +41,6 @@ const ImagePreview = () => {
   const [image, setImage] = useState<string>();
   const [loading, setLoading] = useState(false);
   const imageRef = useRef<ImageAttributes>();
-  const insets = useGlobalSafeAreaInsets();
-  const [showHeader, setShowHeader] = useState(true);
 
   useEffect(() => {
     eSubscribeEvent("ImagePreview", open);
@@ -80,86 +73,16 @@ const ImagePreview = () => {
         silent: true,
         cache: true
       });
-
-      if (!uri) {
-        setLoading(false);
-        return;
-      }
-      const attachment = await db.attachments.attachment(hash);
-      const path = `${cacheDir}/${
-        "NN_" + (await getFileNameWithExtension(hash, attachment?.mimeType))
-      }`;
-      await RNFetchBlob.fs.mv(`${cacheDir}/${uri}`, path).catch(() => {
-        /* empty */
-      });
+      const path = `${cacheDir}/${uri}`;
       setImage("file://" + path);
       setLoading(false);
     }, 100);
   };
 
-  const close = React.useCallback(() => {
-    image &&
-      RNFetchBlob.fs.unlink(image.replace("file://", "")).catch(() => {
-        /* empty */
-      });
+  const close = () => {
     setImage(undefined);
     setVisible(false);
-  }, [image]);
-
-  const renderHeader = React.useCallback(
-    () => (
-      <View
-        style={{
-          paddingTop: insets.top,
-          backgroundColor: "rgba(0,0,0,0.3)",
-          position: "absolute",
-          zIndex: 999,
-          display: showHeader ? "flex" : "none"
-        }}
-      >
-        <View
-          style={{
-            flexDirection: "row",
-            width: "100%",
-            justifyContent: "flex-end",
-            alignItems: "center",
-            height: 50,
-            paddingHorizontal: 12,
-            gap: 10
-          }}
-        >
-          <IconButton
-            name="share"
-            color="white"
-            style={{
-              borderWidth: 0
-            }}
-            onPress={async () => {
-              useSettingStore
-                .getState()
-                .setAppDidEnterBackgroundForAction(true);
-              await Share.open({
-                url: image
-              }).catch(() => {
-                /* empty */
-              });
-              useSettingStore
-                .getState()
-                .setAppDidEnterBackgroundForAction(false);
-            }}
-          />
-          <IconButton
-            name="close"
-            color="white"
-            onPress={() => {
-              close();
-            }}
-          />
-        </View>
-      </View>
-    ),
-    [close, image, insets.top, showHeader]
-  );
+  };
 
   return (
     visible && (
@@ -167,7 +90,6 @@ const ImagePreview = () => {
         background="black"
         animation="slide"
         visible={true}
-        useSafeArea={false}
         onRequestClose={close}
         transparent
       >
@@ -208,25 +130,43 @@ const ImagePreview = () => {
               />
             </View>
           ) : (
-            <>
-              <ImageViewer
-                enableImageZoom={true}
-                renderIndicator={() => <></>}
-                enableSwipeDown
-                useNativeDriver
-                onSwipeDown={close}
-                saveToLocalByLongPress={false}
-                onClick={() => {
-                  setShowHeader(!showHeader);
-                }}
-                renderHeader={renderHeader}
-                imageUrls={[
-                  {
-                    url: image as string
-                  }
-                ]}
-              />
-            </>
+            <ImageViewer
+              enableImageZoom={true}
+              renderIndicator={() => <></>}
+              enableSwipeDown
+              useNativeDriver
+              onSwipeDown={close}
+              saveToLocalByLongPress={false}
+              renderHeader={() => (
+                <View
+                  style={{
+                    flexDirection: "row",
+                    width: "100%",
+                    justifyContent: "flex-end",
+                    alignItems: "center",
+                    height: 50,
+                    paddingHorizontal: 24,
+                    position: "absolute",
+                    zIndex: 999,
+                    backgroundColor: "rgba(0,0,0,0.3)",
+                    marginTop: Platform.OS === "android" ? 30 : 0
+                  }}
+                >
+                  <IconButton
+                    name="close"
+                    color="white"
+                    onPress={() => {
+                      close();
+                    }}
+                  />
+                </View>
+              )}
+              imageUrls={[
+                {
+                  url: image as string
+                }
+              ]}
+            />
           )}
         </View>
       </BaseDialog>

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/list/list-item.wrapper.tsx

@@ -153,7 +153,9 @@ export function ListItemWrapper(props: ListItemWrapperProps) {
           },
           items?.cacheItem(index) ? 100 : 0
         );
-      } catch (e) {}
+      } catch (e) {
+        console.log("Error", e);
+      }
     })();
   }, [index, items, refreshItem]);
 

apps/mobile/app/components/premium/pricing-plans.tsx

@@ -119,6 +119,7 @@ export const PricingPlans = ({
       setLoading(false);
     } catch (e) {
       setLoading(false);
+      console.log("error getting sku", e);
     }
   }, [promo?.promoCode]);
 
@@ -170,6 +171,7 @@ export const PricingPlans = ({
       });
       return true;
     } catch (e) {
+      console.log("PROMOCODE ERROR:", code, e);
       return false;
     }
   };
@@ -229,6 +231,7 @@ export const PricingPlans = ({
       });
     } catch (e) {
       setBuying(false);
+      console.log(e);
     }
   };
 

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/add-notebook/index.tsx

@@ -100,6 +100,7 @@ export const AddNotebookSheet = ({
     eSendEvent(eOnNotebookUpdated, parent);
     if (notebook) {
       setImmediate(() => {
+        console.log(parent, notebook.id);
         eSendEvent(eOnNotebookUpdated, notebook.id);
       });
     }

apps/mobile/app/components/sheets/add-to/notebook-item.tsx

@@ -90,12 +90,13 @@ export const NotebookItem = ({
       for (const key in keys) {
         nextState[key] = !state.initialState[key] ? undefined : "deselected";
       }
-
+      console.log("Single item selection");
       state.setSelection({
         [item.id]: "selected",
         ...nextState
       });
     } else {
+      console.log("Multi item selection");
       state.markAs(item, "selected");
     }
   };

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/export-notes/index.tsx

@@ -333,17 +333,13 @@ const ExportNotesSheet = ({
                     if (Platform.OS === "ios") {
                       Share.open({
                         url: result?.fileDir + result.fileName
-                      }).catch(() => {
-                        /* empty */
-                      });
+                      }).catch(console.log);
                     } else {
                       FileViewer.open(result.filePath, {
                         showOpenWithDialog: true,
                         showAppsSuggestions: true,
                         shareFile: true
-                      } as any).catch(() => {
-                        /* empty */
-                      });
+                      } as any).catch(console.log);
                     }
                   }}
                 />

apps/mobile/app/components/sheets/export-notes/share.jsx

@@ -62,9 +62,7 @@ export const ShareComponent = ({ uri, name, padding }) => {
             showOpenWithDialog: true,
             showAppsSuggestions: true,
             shareFile: true
-          }).catch(() => {
-            /* empty */
-          });
+          }).catch(console.log);
         }}
       />
     </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/manage-tags/index.tsx

@@ -113,9 +113,11 @@ const ManageTagsSheet = (props: {
         .sorted()
         .then((items) => {
           setTags(items);
+          console.log("searched tags");
         });
     } else {
       db.tags.all.sorted(db.settings.getGroupOptions("tags")).then((items) => {
+        console.log("items loaded tags", items.placeholders.length);
         setTags(items);
       });
     }

apps/mobile/app/components/sheets/recovery-key/index.jsx

@@ -191,17 +191,13 @@ class RecoveryKeySheet extends React.Component {
         Share.open({
           url: path,
           failOnCancel: false
-        }).catch(() => {
-          /* empty */
-        });
+        }).catch(console.log);
       } else {
         FileViewer.open(path, {
           showOpenWithDialog: true,
           showAppsSuggestions: true,
           shareFile: true
-        }).catch(() => {
-          /* empty */
-        });
+        }).catch(console.log);
       }
     } catch (e) {
       console.error(e);

apps/mobile/app/components/sheets/references/index.tsx

@@ -273,7 +273,7 @@ const ListNoteItem = ({
     listType,
     noteInternalLinks.length
   ]);
-
+  console.log(noteInternalLinks);
   const renderBlock = React.useCallback(
     (block: ContentBlock) => (
       <ListBlockItem
@@ -419,6 +419,7 @@ export const ReferencesList = ({ item, close }: ReferencesListProps) => {
         id={index}
         items={items}
         onSelect={(note, blockId) => {
+          console.log(note.id, blockId);
           eSendEvent(eOnLoadNote, {
             item: note,
             blockId: blockId

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

@@ -38,7 +38,7 @@ const Sort = ({ type, screen }) => {
   );
   const updateGroupOptions = async (_groupOptions) => {
     const groupType = screen === "Notes" ? "home" : type + "s";
-
+    console.log("updateGroupOptions for group", groupType, "in", screen);
     await db.settings.setGroupOptions(groupType, _groupOptions);
     setGroupOptions(_groupOptions);
     setTimeout(() => {

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
@@ -217,9 +215,7 @@ export const Update = ({ version: appVersion, fwdRef }) => {
               marginTop: 10
             }}
             onPress={() => {
-              Linking.openURL(GITHUB_PAGE_URL).catch(() => {
-                /* empty */
-              });
+              Linking.openURL(GITHUB_PAGE_URL).catch(console.log);
             }}
           >
             {strings.readReleaseNotes()}

apps/mobile/app/components/ui/pressable/index.tsx

@@ -263,22 +263,20 @@ export const Pressable = ({
   const getStyle = useCallback(
     ({ pressed }: PressableStateCallbackType): ViewStyle | ViewStyle[] => [
       {
-        backgroundColor:
-          pressed && !disabled
-            ? RGB_Linear_Shade(alpha, hexToRGBA(selectedColor, opacity || 1))
-            : hexToRGBA(primaryColor, opacity || 1),
+        backgroundColor: pressed
+          ? RGB_Linear_Shade(alpha, hexToRGBA(selectedColor, opacity || 1))
+          : hexToRGBA(primaryColor, opacity || 1),
         width: "100%",
         alignSelf: "center",
         borderRadius: noborder ? 0 : br,
         justifyContent: "center",
         alignItems: "center",
         marginBottom: 0,
-        borderColor:
-          pressed && !disabled
-            ? customSelectedColor
-              ? getColorLinearShade(customSelectedColor, 0.3, false)
-              : borderSelectedColor || borderColor
-            : borderColor || "transparent",
+        borderColor: pressed
+          ? customSelectedColor
+            ? getColorLinearShade(customSelectedColor, 0.3, false)
+            : borderSelectedColor || borderColor
+          : borderColor || "transparent",
         borderWidth: borderWidth
       },
       style,
@@ -300,8 +298,7 @@ export const Pressable = ({
       borderColor,
       borderWidth,
       style,
-      growFactor,
-      disabled
+      growFactor
     ]
   );
 

apps/mobile/app/components/ui/sheet/index.js

@@ -59,9 +59,8 @@ const SheetWrapper = ({
   const smallTablet = deviceMode === "smallTablet";
   const dimensions = useSettingStore((state) => state.dimensions);
   const insets = useGlobalSafeAreaInsets();
+  const appState = useAppState();
   const lockEvents = useRef(false);
-  const locked = useUserStore((state) => state.appLocked);
-
   let width = dimensions.width > 600 ? 600 : 500;
 
   const style = React.useMemo(() => {
@@ -100,21 +99,24 @@ const SheetWrapper = ({
   };
 
   useEffect(() => {
-    if (locked) {
-      const ref = fwdRef || localRef;
-      ref?.current?.hide();
-      if (useUserStore.getState().appLocked) {
-        lockEvents.current = true;
-        const unsub = useUserStore.subscribe((state) => {
-          if (!state.appLocked) {
-            ref?.current?.show();
-            unsub();
-            lockEvents.current = false;
-          }
-        });
+    if (useUserStore.getState().disableAppLockRequests) return;
+    if (SettingsService.canLockAppInBackground()) {
+      if (appState === "background") {
+        const ref = fwdRef || localRef;
+        ref?.current?.hide();
+        if (useUserStore.getState().appLocked) {
+          lockEvents.current = true;
+          const unsub = useUserStore.subscribe((state) => {
+            if (!state.appLocked) {
+              ref?.current?.show();
+              unsub();
+              lockEvents.current = false;
+            }
+          });
+        }
       }
     }
-  }, [locked, fwdRef]);
+  }, [appState, fwdRef]);
 
   return (
     <ScopedThemeProvider value="sheet">

apps/mobile/app/components/walkthroughs/walkthroughs.tsx

@@ -315,9 +315,7 @@ const trialstarted: { id: string; steps: TStep[] } = {
       actionButton: {
         text: strings.joinDiscord(),
         action: () => {
-          Linking.openURL("https://discord.gg/zQBK97EE22").catch(() => {
-            /* empty */
-          });
+          Linking.openURL("https://discord.gg/zQBK97EE22").catch(console.log);
         }
       }
     }
@@ -368,9 +366,7 @@ const Support = () => {
           width: "90%"
         }}
         onPress={() => {
-          Linking.openURL("https://discord.gg/zQBK97EE22").catch(() => {
-            /* empty */
-          });
+          Linking.openURL("https://discord.gg/zQBK97EE22").catch(console.log);
         }}
         icon="discord"
         type="secondary"
@@ -384,9 +380,7 @@ const Support = () => {
           width: "90%"
         }}
         onPress={() => {
-          Linking.openURL("https://t.me/notesnook").catch(() => {
-            /* empty */
-          });
+          Linking.openURL("https://t.me/notesnook").catch(console.log);
         }}
         icon="telegram"
         type="secondary"

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";
@@ -99,6 +94,7 @@ import {
   eLoginSessionExpired,
   eOnLoadNote,
   eOpenAnnouncementDialog,
+  eUnlockNote,
   eUserLoggedIn,
   refreshNotesPage
 } from "../utils/events";
@@ -152,6 +148,7 @@ const onUploadedAttachmentProgress = (data: any) => {
 };
 
 const onUserSessionExpired = async () => {
+  console.log("LOGGED OUT USER....");
   SettingsService.set({
     sessionExpired: true
   });
@@ -160,7 +157,6 @@ const onUserSessionExpired = async () => {
 
 const onAppOpenedFromURL = async (event: { url: string }) => {
   const url = event.url;
-
   try {
     if (url.startsWith("https://app.notesnook.com/account/verified")) {
       await onUserEmailVerified();
@@ -170,25 +166,6 @@ const onAppOpenedFromURL = async (event: { url: string }) => {
       eSendEvent(eOnLoadNote, { newNote: true });
       tabBarRef.current?.goToPage(1, false);
       return;
-    } else if (url.startsWith("https://notesnook.com/open_note")) {
-      const id = new URL(url).searchParams.get("id");
-      if (id) {
-        const note = await db.notes.note(id);
-        if (note) {
-          eSendEvent(eOnLoadNote, {
-            item: note
-          });
-          tabBarRef.current?.goToPage(1, false);
-        }
-      }
-    } else if (url.startsWith("https://notesnook.com/open_reminder")) {
-      const id = new URL(url).searchParams.get("id");
-      if (id) {
-        const reminder = await db.reminders.reminder(id);
-        if (reminder) ReminderSheet.present(reminder);
-      }
-    } else if (url.startsWith("https://notesnook.com/new_reminder")) {
-      ReminderSheet.present();
     }
   } catch (e) {
     console.error(e);
@@ -245,7 +222,6 @@ const onLogout = async (reason: string) => {
   await PremiumService.setPremiumStatus();
   await BiometricService.resetCredentials();
   MMKV.clearStore();
-  resetTabStore();
   clearAllStores();
   setImmediate(() => {
     refreshAllStores();
@@ -278,7 +254,9 @@ async function checkForShareExtensionLaunchedInBackground() {
       if (note) setTimeout(() => eSendEvent("loadingNote", note), 1);
       MMKV.removeItem("shareExtensionOpened");
     }
-  } catch (e) {}
+  } catch (e) {
+    console.log(e);
+  }
 }
 
 async function saveEditorState() {
@@ -524,9 +502,7 @@ export const useAppEvents = () => {
       }
 
       if (SettingsService.getProperty("offlineMode")) {
-        db.attachments.cacheAttachments().catch(() => {
-          /* empty */
-        });
+        db.attachments.cacheAttachments().catch(console.log);
       }
     }
   }, []);
@@ -574,6 +550,7 @@ export const useAppEvents = () => {
           });
         }
       } catch (e) {
+        console.log(e);
         ToastManager.error(e as Error, "Error updating user", "global");
       }
 
@@ -644,17 +621,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);
+            }
           }
         }
       }),
@@ -663,7 +645,6 @@ export const useAppEvents = () => {
 
     const emitterSubscriptions = [
       Linking.addEventListener("url", onAppOpenedFromURL),
-
       SodiumEventEmitter.addListener(
         "onSodiumProgress",
         onFileEncryptionProgress
@@ -749,15 +730,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
       );
@@ -800,7 +779,9 @@ export const useAppEvents = () => {
   useEffect(() => {
     if (!appLocked && isAppLoading) {
       initializeLogger()
-        .catch((e) => {})
+        .catch((e) => {
+          console.log(e);
+        })
         .finally(() => {
           //@ts-ignore
           initializeDatabase();

apps/mobile/app/hooks/use-db-item.ts

@@ -196,6 +196,7 @@ export const useTotalNotes = (type: "notebook" | "tag" | "color") => {
           }
           setTotalNotesById(totalNotesById);
         });
+      console.log("useTotalNotes.getTotalNotes");
     },
     [type]
   );

apps/mobile/app/hooks/use-group-options.ts

@@ -31,7 +31,7 @@ export function useGroupOptions(type: any) {
     const onUpdate = (groupType: string) => {
       if (groupType !== type) return;
       const options = db.settings?.getGroupOptions(type) as any;
-
+      console.log("useGroupOptions.onUpdate", type, options);
       if (
         groupOptions?.groupBy !== options.groupBy ||
         groupOptions?.sortBy !== options.sortBy ||

apps/mobile/app/hooks/use-notebook.ts

@@ -74,8 +74,10 @@ export const useNotebook = (
     };
 
     const onUpdate = (type: string) => {
+      console.log("event", type);
       if (type !== "notebooks") return;
       onRequestUpdate();
+      console.log("useNotebook.onUpdate", item?.id, Date.now());
     };
 
     eSubscribeEvent(eGroupOptionsUpdated, onUpdate);

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,7 @@ 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";
 
 const NativeStack = createNativeStackNavigator();
 const IntroStack = createNativeStackNavigator();
@@ -76,12 +76,11 @@ const _Tabs = () => {
   const introCompleted = useSettingStore(
     (state) => state.settings.introCompleted
   );
-
   const height = useSettingStore((state) => state.dimensions.height);
   const insets = useGlobalSafeAreaInsets();
   const screenHeight = height - (50 + insets.top + insets.bottom);
   React.useEffect(() => {
-    setTimeout(async () => {
+    setTimeout(() => {
       useNavigationStore.getState().update(homepage);
     }, 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

@@ -9,13 +9,13 @@
     "@streetwriters/showdown": "^3.0.1-alpha.2",
     "absolutify": "^0.1.0",
     "buffer": "^6.0.3",
+    "dayjs": "^1.10.4",
     "deprecated-react-native-prop-types": "^4.1.0",
     "entities": "^3.0.1",
     "fflate": "^0.7.3",
     "html-to-text": "9.0.5",
     "phone": "^3.1.14",
     "qclone": "^1.2.0",
-    "dayjs": "^1.11.13",
     "react-native-actions-sheet": "0.9.7",
     "react-native-drax": "^0.10.2",
     "react-native-image-zoom-viewer": "^3.0.1",
@@ -36,15 +36,10 @@
     "@streetwriters/kysely": "^0.27.4",
     "pathe": "1.1.2",
     "react-native-format-currency": "0.0.5",
-    "@lingui/core": "5.1.2",
-    "@lingui/react": "5.1.2",
+    "@lingui/react": "4.11.2",
+    "@lingui/core": "4.11.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;
+        if (!tabRef.current?.noteLocked || !tabRef.current) return;
         console.log("Trying to unlock with biometrics...");
         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,10 +299,13 @@ const useLockedNoteHandler = () => {
           }
         }
         eSendEvent(eOnLoadNote, {
-          item: note,
-          refresh: true
+          item: note
+        });
+        useTabStore.getState().updateTab(tabRef.current.id, {
+          locked: false
         });
       } catch (e) {
+        console.log(e);
         ToastManager.show({
           heading: strings.passwordIncorrect(),
           type: "error"
@@ -322,7 +315,7 @@ const useLockedNoteHandler = () => {
 
     const unlock = () => {
       if (
-        (tabRef.current?.session?.locked,
+        (tabRef.current?.locked,
         useTabStore.getState().biometryAvailable &&
           useTabStore.getState().biometryEnrolled &&
           !editorState().movedAway)
@@ -331,9 +324,10 @@ const useLockedNoteHandler = () => {
           unlockWithBiometrics();
         }, 150);
       } else {
+        console.log("Biometrics unavailable.", editorState().movedAway);
         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 +342,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,12 @@ 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) {
+      console.log("Readonly editor loaded.");
       props.onLoad?.((content: { data: string; id: string }) => {
         setTimeout(() => {
           noteId.current = content.id;
@@ -86,9 +87,10 @@ 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;
 
+      console.log("Getting attachment data:", attachment.hash, attachment.type);
       downloadAttachment(attachment.hash, true, {
         base64: attachment.type === "image",
         text: attachment.type === "web-clip",
@@ -104,7 +106,7 @@ export function ReadonlyEditor(props: {
           );
           editorRef.current?.postMessage(
             JSON.stringify({
-              type: NativeEvents.attachmentData,
+              type: EditorEvents.attachmentData,
               value: {
                 resolverId: (editorMessage.value as any).resolverId,
                 data
@@ -113,9 +115,10 @@ export function ReadonlyEditor(props: {
           );
         })
         .catch(() => {
+          console.log("Error downloading attachment data");
           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

@@ -43,7 +43,6 @@ import { eCloseSheet } from "../../../utils/events";
 import { useTabStore } from "./use-tab-store";
 import { editorController, editorState } from "./utils";
 import { strings } from "@notesnook/intl";
-import { useUserStore } from "../../../stores/use-user-store";
 
 const showEncryptionSheet = (file: DocumentPickerResponse) => {
   presentSheet({
@@ -61,7 +60,7 @@ const santizeUri = (uri: string) => {
 
 type PickerOptions = {
   noteId?: string;
-  tabId?: string;
+  tabId?: number;
   type: "image" | "camera" | "file";
   reupload: boolean;
   hash?: string;
@@ -132,6 +131,7 @@ const file = async (fileOptions: PickerOptions) => {
 
     if (
       fileOptions.tabId !== undefined &&
+      fileOptions.noteId &&
       useTabStore.getState().getNoteIdForTab(fileOptions.tabId) ===
         fileOptions.noteId
     ) {
@@ -194,7 +194,9 @@ const camera = async (options: PickerOptions) => {
           options
         );
       })
-      .catch((e) => {});
+      .catch((e) => {
+        console.log("camera error: ", e);
+      });
   } catch (e) {
     ToastManager.show({
       heading: (e as Error).message,
@@ -222,7 +224,9 @@ const gallery = async (options: PickerOptions) => {
           options
         )
       )
-      .catch((e) => {});
+      .catch((e) => {
+        console.log("gallery error: ", e);
+      });
   } catch (e) {
     useSettingStore.getState().setAppDidEnterBackgroundForAction(false);
     ToastManager.show({
@@ -230,19 +234,13 @@ const gallery = async (options: PickerOptions) => {
       type: "error",
       context: "global"
     });
+    console.log("attachment error:", e);
   }
 };
 
 const pick = async (options: PickerOptions) => {
   if (!PremiumService.get()) {
     const user = await db.user.getUser();
-    if (!user) {
-      ToastManager.show({
-        heading: strings.loginRequired(),
-        type: "error"
-      });
-      return;
-    }
     if (editorState().isFocused) {
       editorState().isFocused = true;
     }
@@ -253,7 +251,6 @@ const pick = async (options: PickerOptions) => {
     }
     return;
   }
-  useUserStore.getState().setDisableAppLockRequests(true);
   if (options?.type.startsWith("image") || options?.type === "camera") {
     if (options.type.startsWith("image")) {
       gallery(options);
@@ -270,7 +267,6 @@ const handleImageResponse = async (
   options: PickerOptions
 ) => {
   const result = await AttachImage.present(response, options.context);
-
   if (!result) return;
   const compress = result.compress;
 
@@ -314,14 +310,18 @@ const handleImageResponse = async (
         ? fileName.replace(/HEIC|HEIF/, "jpeg")
         : fileName;
 
+    console.log("attaching image...", fileName);
+
+    console.log("attaching file...");
     if (!(await attachFile(uri, hash, image.mime, fileName, options))) return;
 
     if (Platform.OS === "ios") await RNFetchBlob.fs.unlink(uri);
-
+    console.log("attaching image to note...");
     if (
       options.tabId !== undefined &&
       useTabStore.getState().getNoteIdForTab(options.tabId) === options.noteId
     ) {
+      console.log("attaching image to note...");
       editorController.current?.commands.insertImage(
         {
           hash: hash,
@@ -388,6 +388,7 @@ export async function attachFile(
       encryptionInfo.mimeType = type;
       encryptionInfo.filename = filename;
       encryptionInfo.alg = "xcha-stream";
+      encryptionInfo.size = encryptionInfo.length;
       encryptionInfo.key = key;
       if (options?.reupload && exists) {
         const attachment = await db.attachments.attachment(hash);
@@ -396,7 +397,6 @@ export async function attachFile(
     } else {
       encryptionInfo = { hash: hash };
     }
-
     await db.attachments.add(encryptionInfo);
     return true;
   } catch (e) {

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;
 };
 
@@ -94,5 +94,4 @@ export type AppState = {
   editing: boolean;
   movedAway: boolean;
   timestamp: number;
-  noteId?: string;
 };

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) {
@@ -269,6 +268,7 @@ export const useEditorEvents = (
   }, [editor, deviceMode, fullscreen]);
 
   const onHardwareBackPress = useCallback(() => {
+    console.log(tabBarRef.current?.page());
     if (tabBarRef.current?.page() === 2) {
       onBackPress();
       return true;
@@ -353,25 +353,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 +381,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 +392,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 +403,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 +419,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 +442,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 +452,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 +468,7 @@ export const useEditorEvents = (
               });
           }
           break;
-        case EditorEvents.filepicker:
+        case EventTypes.filepicker:
           editorState().isAwaitingResult = true;
           const { pick } = require("./picker").default;
           pick({
@@ -480,14 +480,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 +507,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 +523,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 +554,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,41 +565,26 @@ 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
           // });
-          //
+          // console.log("Tabs updated");
           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 +596,27 @@ export const useEditorEvents = (
           });
           break;
         }
-        case EditorEvents.tabFocused: {
+        case EventTypes.tabFocused: {
+          console.log(
+            "Focused tab",
+            editorMessage.tabId,
+            editorMessage.noteId,
+            "Content:",
+            editorMessage.value
+          );
+
           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 +628,7 @@ export const useEditorEvents = (
                   if (note) {
                     eSendEvent(eOnLoadNote, {
                       item: note,
+                      forced: true,
                       tabId: editorMessage.tabId
                     });
                   }
@@ -641,7 +639,7 @@ export const useEditorEvents = (
 
           break;
         }
-        case EditorEvents.createInternalLink: {
+        case EventTypes.createInternalLink: {
           LinkNote.present(
             editorMessage.value.attributes,
             editorMessage.resolverId as string
@@ -649,37 +647,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";
@@ -49,7 +46,6 @@ import {
   eUnSubscribeEvent
 } from "../../../services/event-manager";
 import Navigation from "../../../services/navigation";
-import { NotePreviewWidget } from "../../../services/note-preview-widget";
 import Notifications from "../../../services/notifications";
 import SettingsService from "../../../services/settings";
 import { useSettingStore } from "../../../stores/use-setting-store";
@@ -66,10 +62,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 +75,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 +98,7 @@ export const useEditor = (
             isPreview?: boolean;
           };
         })
+      | null
       | undefined
     >
   >({});
@@ -171,17 +118,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 +141,7 @@ export const useEditor = (
   }, [commands, insets, isDefaultEditor]);
 
   useEffect(() => {
-    postMessage(NativeEvents.theme, theme);
+    postMessage(EditorEvents.theme, theme);
   }, [theme, postMessage]);
 
   useEffect(() => {
@@ -206,14 +151,15 @@ export const useEditor = (
   }, [commands, tags]);
 
   useEffect(() => {
-    const event = eSubscribeEvent(eEditorTabFocused, (tabId: string) => {
+    const event = eSubscribeEvent(eEditorTabFocused, (tabId) => {
+      console.log("Editot tab focus changed", lastTabFocused.current, 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,12 @@ export const useEditor = (
   );
 
   const reset = useCallback(
-    async (tabId: string, resetState = true, resetContent = true) => {
+    async (tabId: number, resetState = true, resetContent = true) => {
+      console.log("Resetting tab:", tabId);
       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 +201,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 +232,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 +270,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 +311,7 @@ export const useEditor = (
             }
 
             useTabStore.getState().updateTab(tabId, {
-              session: {
-                noteId: id
-              }
+              noteId: id
             });
 
             const defaultNotebook = db.settings.getDefaultNotebook();
@@ -377,7 +326,7 @@ export const useEditor = (
 
             if (!noteData.title) {
               postMessage(
-                NativeEvents.title,
+                EditorEvents.title,
                 currentNotes.current[id]?.title,
                 tabId
               );
@@ -437,19 +386,12 @@ 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;
         }
 
         saveCount.current++;
-
-        clearTimeout(timers.current.onsave);
-        timers.current.onsave = setTimeout(async () => {
-          if (!id || !note) return;
-          NotePreviewWidget.updateNote(id, note);
-        }, 500);
-
         return id;
       } catch (e) {
         console.error(e);
@@ -487,222 +429,183 @@ 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;
+      console.log(event.item?.id, event?.item?.title, "loading note...");
+
+      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;
         }
+        console.log("LOADING NOTE", event.item.id);
+        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);
+        }
+        const isLockedNote = await db.vaults.itemExists(
+          event.item as ItemReference
+        );
+        const tabLocked =
+          isLockedNote && !(event.item as NoteWithContent).content;
+
+        // 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);
+            }
+            console.log("Note already loaded, focusing the tab");
+          } else {
+            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
+              });
+              console.log("Opening note in new tab");
+            } else {
+              console.log("Opening note in preview tab");
+              // 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) {
+          //   console.log("tab id did not match after focus in 1000ms");
+          //   return;
+          // }
+          currentLoadingNoteId.current = item.id;
+          console.log("Waiting for tab to focus");
+          return;
+        }
+
+        state.current.movedAway = false;
         state.current.currentlyEditing = true;
 
+        if (!tabLocked) {
+          await loadContent(item);
+        }
+
         if (
-          !state.current.ready &&
-          (await isEditorLoaded(
-            editorRef,
-            sessionIdRef.current,
-            useTabStore.getState().currentTab!
-          ))
+          currentNotes.current[item.id] &&
+          loadingState.current &&
+          currentContents.current[item.id]?.data &&
+          loadingState.current === currentContents.current[item.id]?.data
         ) {
-          state.current.ready = true;
+          // If note is already loading, return.
+          console.log("Note is already loading...");
+          return;
         }
-        if (event.newNote && !currentLoadingNoteId.current) {
-          let tabId;
 
-          const currentTab = useTabStore
-            .getState()
-            .getTab(useTabStore.getState().currentTab as string);
-
-          if (useTabStore.getState().tabs.length === 0 || currentTab?.pinned) {
-            tabId = useTabStore.getState().newTab();
-          } 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;
-            } 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
-              });
-            }
-          }
-
-          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;
+        if (!state.current.ready) {
           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);
-      });
+
+        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 +613,7 @@ export const useEditor = (
       loadContent,
       overlay,
       postMessage,
+      readonly,
       reset,
       theme
     ]
@@ -721,116 +625,97 @@ 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) {
+              console.log("Removing tab");
+              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 +723,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 +778,7 @@ export const useEditor = (
       content?: string;
       type: string;
       ignoreEdit: boolean;
-      tabId: string;
+      tabId: number;
       pendingChanges?: boolean;
     }) => {
       DatabaseLogger.log(
@@ -939,13 +807,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 +859,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 +890,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,63 +903,36 @@ 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);
-        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
-            });
-          }
-        }
+    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
+        });
       }
-      state.current.initialLoadCalled = true;
-      overlay(false);
     }
+    if (!state.current?.initialLoadCalled) {
+      state.current.initialLoadCalled = true;
+    }
+    overlay(false);
   }, [
     postMessage,
     theme,

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,366 +69,149 @@ 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">
-      ) => {},
-
-      removeTab: (id: string) => {
+      ) => {
+        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
+        };
+        console.log("focus preview", noteId);
+        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();
+        console.log("focus empty tab", get().tabs[index]);
 
         get().focusTab(get().tabs[index].id);
       },
@@ -450,46 +224,38 @@ export const useTabStore = create<TabStore>(
         syncTabs();
       },
 
-      focusTab: (id: string) => {
+      focusTab: (id: number) => {
+        console.log(history.getHistory(), id);
         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
@@ -124,6 +135,7 @@ export const waitForEvent = async (
     };
     eSubscribeEvent(type, callback);
     setTimeout(() => {
+      console.log("return..");
       eUnSubscribeEvent(type, callback);
       resolve(false);
     }, waitFor);
@@ -146,9 +158,6 @@ const canRestoreAppState = (appState: AppState) => {
 };
 
 let appState: AppState | undefined;
-export function setAppState(state: AppState) {
-  appState = state;
-}
 export function getAppState() {
   if (appState && canRestoreAppState(appState)) return appState as AppState;
   const json = NotesnookModule.getAppState();
@@ -174,7 +183,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/note-preview-configure/index.tsx

@@ -1,169 +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 { Note, VirtualizedGrouping } from "@notesnook/core";
-import { useThemeColors } from "@notesnook/theme";
-import React, { useEffect, useState } from "react";
-import { FlatList, TouchableOpacity, View } from "react-native";
-import { db } from "../../common/database";
-import { Header } from "../../components/header";
-import Input from "../../components/ui/input";
-import Paragraph from "../../components/ui/typography/paragraph";
-import { useDBItem } from "../../hooks/use-db-item";
-import useGlobalSafeAreaInsets from "../../hooks/use-global-safe-area-insets";
-import { useSettingStore } from "../../stores/use-setting-store";
-import { NotesnookModule } from "../../utils/notesnook-module";
-
-const NoteItem = (props: {
-  id: string | number;
-  items?: VirtualizedGrouping<Note>;
-}) => {
-  const { colors } = useThemeColors();
-  const [item] = useDBItem(props.id, "note", props.items);
-
-  return (
-    <TouchableOpacity
-      activeOpacity={0.7}
-      onPress={() => {
-        const widgetId = NotesnookModule.getWidgetId();
-        NotesnookModule.setString(
-          "appPreview",
-          String(widgetId),
-          JSON.stringify(item)
-        );
-        setTimeout(() => {
-          NotesnookModule.saveAndFinish();
-        });
-      }}
-      style={{
-        flexDirection: "column",
-        borderBottomWidth: 1,
-        borderBottomColor: colors.primary.border,
-        justifyContent: "center",
-        paddingVertical: 12,
-        minHeight: 45
-      }}
-    >
-      {!item ? null : (
-        <View
-          style={{
-            flexDirection: "row",
-            paddingHorizontal: 12
-          }}
-        >
-          <View
-            style={{
-              flexDirection: "column"
-            }}
-          >
-            <Paragraph
-              numberOfLines={1}
-              style={{
-                color: colors.primary.paragraph,
-                fontSize: 15
-              }}
-            >
-              {item.title}
-            </Paragraph>
-          </View>
-        </View>
-      )}
-    </TouchableOpacity>
-  );
-};
-
-export const NotePreviewConfigure = () => {
-  const [items, setItems] = useState<VirtualizedGrouping<Note>>();
-  const loading = useSettingStore((state) => state.isAppLoading);
-  const bounceRef = React.useRef<NodeJS.Timeout>();
-  const { colors } = useThemeColors();
-  const insets = useGlobalSafeAreaInsets();
-
-  useEffect(() => {
-    useSettingStore.getState().setDeviceMode("mobile");
-    if (loading) return;
-    db.notes.all.sorted(db.settings.getGroupOptions("notes")).then((notes) => {
-      setItems(notes);
-    });
-  }, [loading]);
-
-  const renderItem = React.useCallback(
-    ({ index }: { item: boolean; index: number }) => {
-      return <NoteItem id={index} items={items} />;
-    },
-    [items]
-  );
-
-  return (
-    <View
-      style={{
-        backgroundColor: colors.primary.background,
-        flex: 1
-      }}
-    >
-      <Header
-        canGoBack
-        title="Select a note"
-        onLeftMenuButtonPress={() => {
-          NotesnookModule.cancelAndFinish();
-        }}
-      />
-
-      <View
-        style={{
-          paddingHorizontal: 12,
-          paddingTop: 6
-        }}
-      >
-        <Input
-          placeholder="Search for notes"
-          containerStyle={{
-            height: 50
-          }}
-          onChangeText={(value) => {
-            bounceRef.current = setTimeout(() => {
-              if (!value) {
-                db.notes.all
-                  .sorted(db.settings.getGroupOptions("notes"))
-                  .then((notes) => {
-                    setItems(notes);
-                  });
-                return;
-              }
-              db.lookup
-                .notes(value)
-                .sorted()
-                .then((notes) => {
-                  setItems(notes);
-                });
-            }, 500);
-          }}
-        />
-
-        <FlatList
-          data={items?.placeholders}
-          keyboardShouldPersistTaps="handled"
-          keyboardDismissMode="interactive"
-          renderItem={renderItem}
-          windowSize={1}
-          ListFooterComponent={<View style={{ height: 200 }} />}
-        />
-      </View>
-    </View>
-  );
-};

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

@@ -284,13 +284,14 @@ NotebookScreen.navigate = async (item: Notebook, canGoBack?: boolean) => {
       focusedRouteId == item?.id
     ) {
       // Update the route in place instead
-
+      console.log("Updating existing route in place");
       eSendEvent(eUpdateNotebookRoute, {
         item: item,
         title: item.title,
         canGoBack: canGoBack
       });
     } else {
+      console.log("Pushing new notebook route");
       // Push a new route
       Navigation.push("Notebook", {
         title: item.title,

apps/mobile/app/screens/notes/colored.tsx

@@ -59,6 +59,7 @@ ColoredNotes.navigate = (item: Color, canGoBack: boolean) => {
   const { focusedRouteId } = useNavigationStore.getState();
 
   if (focusedRouteId === item.id) {
+    console.log("ColoredNotes.navigate: route already focused for color");
     return;
   }