mobile: fix release notes rendering

This happened due to [Symbol.asyncIterable] not getting
transformed when it was a method of a class. Moving it inside
another method fixes the issue.

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

@@ -14,6 +14,8 @@ 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
@@ -24,3 +26,4 @@ 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-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 40
     env:
       CMAKE_C_COMPILER_LAUNCHER: ccache

.github/workflows/desktop.publish.yml

@@ -49,6 +49,13 @@ 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: |
@@ -57,6 +64,10 @@ jobs:
       - name: Generate desktop build
         run: 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:
@@ -71,7 +82,8 @@ jobs:
 
       - name: Package desktop build
         run: |
-          zip -r ./notesnook_build_v${{ steps.app_metadata.outputs.app_version }}.zip ./apps/web/build/
+          cp -r ./apps/web/build ./apps/desktop/
+          zip -r ./notesnook_build_v${{ steps.app_metadata.outputs.app_version }}.zip ./apps/desktop/build/
           echo "Build folder archived to ./notesnook_build_v${{ steps.app_metadata.outputs.app_version }}.zip"
 
       - name: Upload desktop build

apps/desktop/package.json

@@ -2,7 +2,7 @@
   "name": "@notesnook/desktop",
   "productName": "Notesnook",
   "description": "Your private note taking space",
-  "version": "3.0.22",
+  "version": "3.0.24",
   "appAppleId": "1544027013",
   "private": true,
   "main": "./dist/cjs/index.js",
@@ -25,7 +25,7 @@
   "repository": "https://github.com/streetwriters/notesnook",
   "license": "GPL-3.0-or-later",
   "dependencies": {
-    "@lingui/core": "4.11.4",
+    "@lingui/core": "5.1.2",
     "@notesnook/intl": "file:../../packages/intl",
     "@trpc/client": "10.45.2",
     "@trpc/server": "10.45.2",
@@ -33,10 +33,10 @@
     "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.24.0",
+    "esbuild": "0.21.5",
+    "vitest": "2.1.8",
     "node-abi": "^3.68.0",
     "node-gyp-build": "^4.8.2",
     "playwright": "^1.48.2",
     "prebuildify": "^6.0.1",
-    "slugify": "^1.6.6",
+    "slugify": "1.6.6",
     "tree-kill": "^1.2.2",
-    "undici": "^6.19.8",
-    "vitest": "^2.1.5"
+    "undici": "^6.19.8"
   },
   "optionalDependencies": {
     "dmg-license": "^1.0.11"

apps/desktop/scripts/build.mjs

@@ -36,7 +36,7 @@ await fs.rm("./build/", { force: true, recursive: true });
 
 if (args.rebuild || !existsSync(path.join(webAppPath, "build"))) {
   await exec(
-    "yarn nx build:desktop @notesnook/web",
+    "npx nx build:desktop @notesnook/web",
     path.join(__dirname, "..", "..", "..")
   );
 }
@@ -58,11 +58,13 @@ if (args.variant === "mas") {
 await exec(`yarn run build`);
 
 if (args.run) {
-  await exec(`yarn electron-builder --dir --x64`);
+  await exec(`yarn electron-builder --dir --${process.arch}`);
   if (process.platform === "win32") {
     await exec(`.\\output\\win-unpacked\\Notesnook.exe`);
   } else if (process.platform === "darwin") {
-    await exec(`./output/mac/Notesnook.app/Contents/MacOS/Notesnook`);
+    if (process.arch === "arm64")
+      await exec(`./output/mac-arm64/Notesnook.app/Contents/MacOS/Notesnook`);
+    else 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(
-      ["yarn", "nx", "start:desktop", "@notesnook/web"],
-      path.join(__dirname, "..", "..", ".."),
+      ["npm", "run", "start:desktop"],
+      path.join(__dirname, "..", "..", "web"),
       (data) => data.includes("Network: use --host to expose")
     );
   }

apps/mobile/app/app.tsx

@@ -32,12 +32,14 @@ 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";
 import { TipManager } from "./services/tip-manager";
 import { useThemeStore } from "./stores/use-theme-store";
 import { useUserStore } from "./stores/use-user-store";
+import { IntentService } from "./services/intent";
 
 I18nManager.allowRTL(false);
 I18nManager.forceRTL(false);
@@ -47,7 +49,8 @@ if (appLockEnabled || appLockMode !== "none") {
   useUserStore.getState().lockApp(true);
 }
 
-const App = () => {
+IntentService.onLaunch();
+const App = (props: { configureMode: "note-preview" }) => {
   useAppEvents();
   //@ts-ignore
   globalThis["IS_MAIN_APP_RUNNING"] = true;
@@ -61,6 +64,7 @@ const App = () => {
       TipManager.init();
     }, 100);
   }, []);
+
   return (
     <View
       style={{
@@ -90,7 +94,11 @@ const App = () => {
           width: "100%"
         }}
       >
-        <ApplicationHolder />
+        {props.configureMode === "note-preview" ? (
+          <NotePreviewConfigure />
+        ) : (
+          <ApplicationHolder />
+        )}
       </GestureHandlerRootView>
       <AppLockedOverlay />
     </View>
@@ -103,8 +111,8 @@ let currTheme =
     : SettingsService.getProperty("lighTheme");
 useThemeEngineStore.getState().setTheme(currTheme);
 
-export const withTheme = (Element: () => JSX.Element) => {
-  return function AppWithThemeProvider() {
+export const withTheme = (Element: (props: any) => JSX.Element) => {
+  return function AppWithThemeProvider(props: any) {
     const [colorScheme, darkTheme, lightTheme] = useThemeStore((state) => [
       state.colorScheme,
       state.darkTheme,
@@ -123,13 +131,14 @@ export const withTheme = (Element: () => JSX.Element) => {
           })
           .then((theme) => {
             if (theme) {
-              console.log(theme.version, "theme updated");
               theme.colorScheme === "dark"
                 ? useThemeStore.getState().setDarkTheme(theme)
                 : useThemeStore.getState().setLightTheme(theme);
             }
           })
-          .catch(console.log);
+          .catch(() => {
+            /* empty */
+          });
       }, 1000);
       // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
@@ -144,7 +153,7 @@ export const withTheme = (Element: () => JSX.Element) => {
 
     return (
       <I18nProvider i18n={i18n}>
-        <Element />
+        <Element {...props} />
       </I18nProvider>
     );
   };

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

@@ -1,385 +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 Sodium from "@ammarahmed/react-native-sodium";
-import { Platform } from "react-native";
-import "react-native-get-random-values";
-import * as Keychain from "react-native-keychain";
-import { MMKVLoader, ProcessingModes } from "react-native-mmkv-storage";
-import { generateSecureRandom } from "react-native-securerandom";
-import { DatabaseLogger } from ".";
-import { MMKV } from "./mmkv";
-import { ToastManager } from "../../services/event-manager";
-
-// Database key cipher is persisted across different user sessions hence it has
-// it's independent storage which we will never clear. This is only used when application has
-// app lock with password enabled.
-export const CipherStorage = new MMKVLoader()
-  .withInstanceID("cipher_storage")
-  .setProcessingMode(
-    Platform.OS === "ios"
-      ? ProcessingModes.MULTI_PROCESS
-      : ProcessingModes.SINGLE_PROCESS
-  )
-  .disableIndexing()
-  .initialize();
-
-const IOS_KEYCHAIN_ACCESS_GROUP = "group.org.streetwriters.notesnook";
-const IOS_KEYCHAIN_SERVICE_NAME = "org.streetwriters.notesnook";
-const KEYCHAIN_SERVER_DBKEY = "notesnook:db";
-
-const NOTESNOOK_APPLOCK_KEY_SALT = "kBwr1Kre86ebOZ8ThLu2OA";
-const NOTESNOOK_DB_KEY_SALT = "SNuzOcEK3amoqL0WvPeKqw";
-
-const DB_KEY_CIPHER = "databaseKeyCipher";
-const USER_KEY_CIPHER = "userKeyCipher";
-const APPLOCK_CIPHER = "applockCipher";
-
-const KEYSTORE_CONFIG = Platform.select({
-  ios: {
-    accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
-    accessGroup: IOS_KEYCHAIN_ACCESS_GROUP,
-    service: IOS_KEYCHAIN_SERVICE_NAME
-  },
-  android: {}
-});
-
-function generatePassword() {
-  const length = 80;
-  const crypto = window.crypto || window.msCrypto;
-  if (typeof crypto === "undefined") {
-    throw new Error(
-      "Crypto API is not supported. Please upgrade your web browser"
-    );
-  }
-  const charset =
-    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!@#$%^&+_{}[]():<>/?;";
-  const indexes = crypto.getRandomValues(new Uint32Array(length));
-  let secret = "";
-  for (const index of indexes) {
-    secret += charset[index % charset.length];
-  }
-  return secret;
-}
-
-export async function encryptDatabaseKeyWithPassword(appLockPassword) {
-  const key = getDatabaseKey();
-  const appLockCredentials = await Sodium.deriveKey(
-    appLockPassword,
-    NOTESNOOK_APPLOCK_KEY_SALT
-  );
-  const databaseKeyCipher = await encrypt(appLockCredentials, key);
-  MMKV.setMap(DB_KEY_CIPHER, databaseKeyCipher);
-  // We reset the database key from keychain once app lock password is set.
-  await Keychain.resetInternetCredentials(KEYCHAIN_SERVER_DBKEY);
-  return true;
-}
-
-export async function restoreDatabaseKeyToKeyChain(appLockPassword) {
-  const databaseKeyCipher = CipherStorage.getMap(DB_KEY_CIPHER);
-  const databaseKey = await decrypt(
-    {
-      password: appLockPassword
-    },
-    databaseKeyCipher
-  );
-
-  await Keychain.setInternetCredentials(
-    KEYCHAIN_SERVER_DBKEY,
-    "notesnook",
-    databaseKey,
-    KEYSTORE_CONFIG
-  );
-  MMKV.removeItem(DB_KEY_CIPHER);
-  return true;
-}
-
-export async function setAppLockVerificationCipher(appLockPassword) {
-  try {
-    const appLockCredentials = await Sodium.deriveKey(
-      appLockPassword,
-      NOTESNOOK_APPLOCK_KEY_SALT
-    );
-    const encrypted = await encrypt(appLockCredentials, generatePassword());
-    CipherStorage.setMap(APPLOCK_CIPHER, encrypted);
-    DatabaseLogger.info("setAppLockVerificationCipher");
-  } catch (e) {
-    DatabaseLogger.error(e);
-    console.log(e);
-  }
-}
-
-export async function clearAppLockVerificationCipher() {
-  CipherStorage.removeItem(APPLOCK_CIPHER);
-}
-
-export async function validateAppLockPassword(appLockPassword) {
-  try {
-    const appLockCipher = CipherStorage.getMap(APPLOCK_CIPHER);
-    if (!appLockCipher) return true;
-    const key = await Sodium.deriveKey(appLockPassword, appLockCipher.salt);
-    const decrypted = await decrypt(key, appLockCipher);
-
-    DatabaseLogger.info(
-      `validateAppLockPassword: ${typeof decrypted === "string"}`
-    );
-    return typeof decrypted === "string";
-  } catch (e) {
-    DatabaseLogger.error(e);
-    return false;
-  }
-}
-
-let DB_KEY;
-export function clearDatabaseKey() {
-  DB_KEY = undefined;
-  DatabaseLogger.info("Cleared database key");
-}
-
-export async function getDatabaseKey(appLockPassword) {
-  if (DB_KEY) return DB_KEY;
-  try {
-    if (appLockPassword) {
-      const databaseKeyCipher = 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) {
-        let credentials = await Keychain.getInternetCredentials(
-          KEYCHAIN_SERVER_DBKEY,
-          KEYSTORE_CONFIG
-        );
-
-        DatabaseLogger.info("Getting database key from Keychain");
-        DB_KEY = credentials.password;
-      }
-    }
-
-    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;
-
-      await Keychain.setInternetCredentials(
-        KEYCHAIN_SERVER_DBKEY,
-        "notesnook",
-        DB_KEY,
-        KEYSTORE_CONFIG
-      );
-    }
-
-    if (await Keychain.hasInternetCredentials("notesnook")) {
-      const userKeyCredentials = await Keychain.getInternetCredentials(
-        "notesnook",
-        KEYSTORE_CONFIG
-      );
-
-      if (userKeyCredentials) {
-        const userKeyCipher = await encrypt(
-          {
-            key: DB_KEY,
-            salt: NOTESNOOK_DB_KEY_SALT
-          },
-          userKeyCredentials.password
-        );
-        // 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, "Error getting database key");
-    console.log(e, "error");
-    DatabaseLogger.error(e);
-    return null;
-  }
-}
-
-export async function deriveCryptoKey(data) {
-  try {
-    let credentials = await Sodium.deriveKey(data.password, data.salt);
-    const userKeyCipher = await encrypt(
-      {
-        key: await getDatabaseKey(),
-        salt: NOTESNOOK_DB_KEY_SALT
-      },
-      credentials.key
-    );
-    DatabaseLogger.info("User key stored: ", !!userKeyCipher);
-
-    // Store encrypted user key in MMKV
-    MMKV.setMap(USER_KEY_CIPHER, userKeyCipher);
-    return credentials.key;
-  } catch (e) {
-    DatabaseLogger.error(e);
-  }
-}
-
-export async function getCryptoKey(_name) {
-  try {
-    const keyCipher = MMKV.getMap(USER_KEY_CIPHER);
-
-    if (!keyCipher) {
-      DatabaseLogger.info("User key cipher is null");
-      return null;
-    }
-
-    const key = await decrypt(
-      {
-        key: await getDatabaseKey(),
-        salt: keyCipher.salt
-      },
-      keyCipher
-    );
-
-    return key;
-  } catch (e) {
-    console.log("getCryptoKey", e);
-    DatabaseLogger.error(e);
-  }
-}
-
-export async function removeCryptoKey(_name) {
-  try {
-    MMKV.removeItem(USER_KEY_CIPHER);
-    await Keychain.resetInternetCredentials("notesnook");
-    return true;
-  } catch (e) {
-    DatabaseLogger.error(e);
-  }
-}
-
-export async function getRandomBytes(length) {
-  return await generateSecureRandom(length);
-}
-
-export async function hash(password, email) {
-  let result = await Sodium.hashPassword(password, email);
-  return result;
-}
-
-export async function generateCryptoKey(password, salt) {
-  try {
-    let credentials = await Sodium.deriveKey(password, salt || null);
-    return credentials;
-  } catch (e) {
-    DatabaseLogger.error(e);
-  }
-}
-
-export function getAlgorithm(base64Variant) {
-  return `xcha-argon2i13-${base64Variant}`;
-}
-
-export async function decrypt(password, data) {
-  if (!password.password && !password.key) return undefined;
-  if (password.password && password.password === "" && !password.key)
-    return undefined;
-  let _data = { ...data };
-  _data.output = "plain";
-
-  if (!password.salt) password.salt = data.salt;
-  return await Sodium.decrypt(password, _data);
-}
-
-export async function decryptMulti(password, data) {
-  if (!password.password && !password.key) return undefined;
-  if (password.password && password.password === "" && !password.key)
-    return undefined;
-
-  data = data.map((d) => {
-    d.output = "plain";
-    return d;
-  });
-
-  if (data.length && !password.salt) {
-    password.salt = data[0].salt;
-  }
-
-  return await Sodium.decryptMulti(password, data);
-}
-
-export function parseAlgorithm(alg) {
-  if (!alg) return {};
-  const [enc, kdf, compressed, compressionAlg, base64variant] = alg.split("-");
-  return {
-    encryptionAlgorithm: enc,
-    kdfAlgorithm: kdf,
-    compressionAlgorithm: compressionAlg,
-    isCompress: compressed === "1",
-    base64_variant: base64variant
-  };
-}
-
-export async function encrypt(password, data) {
-  if (!password.password && !password.key) return undefined;
-  if (password.password && password.password === "" && !password.key)
-    return undefined;
-
-  let message = {
-    type: "plain",
-    data: data
-  };
-  let result = await Sodium.encrypt(password, message);
-
-  return {
-    ...result,
-    alg: getAlgorithm(7)
-  };
-}
-
-export async function encryptMulti(password, data) {
-  if (!password.password && !password.key) return undefined;
-  if (password.password && password.password === "" && !password.key)
-    return undefined;
-
-  let results = await Sodium.encryptMulti(
-    password,
-    data.map((item) => ({
-      type: "plain",
-      data: item
-    }))
-  );
-
-  return !results
-    ? []
-    : results.map((result) => ({
-        ...result,
-        alg: getAlgorithm(7)
-      }));
-}

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

@@ -0,0 +1,473 @@
+/*
+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 Sodium, { Cipher, Password } from "@ammarahmed/react-native-sodium";
+import { SerializedKey } from "@notesnook/crypto";
+import { Platform } from "react-native";
+import "react-native-get-random-values";
+import * as Keychain from "react-native-keychain";
+import { MMKVLoader, ProcessingModes } from "react-native-mmkv-storage";
+import { generateSecureRandom } from "react-native-securerandom";
+import { DatabaseLogger } from ".";
+import { ToastManager } from "../../services/event-manager";
+import { MMKV } from "./mmkv";
+
+// Database key cipher is persisted across different user sessions hence it has
+// it's independent storage which we will never clear. This is only used when application has
+// app lock with password enabled.
+export const CipherStorage = new MMKVLoader()
+  .withInstanceID("cipher_storage")
+  .setProcessingMode(
+    Platform.OS === "ios"
+      ? ProcessingModes.MULTI_PROCESS
+      : ProcessingModes.SINGLE_PROCESS
+  )
+  .disableIndexing()
+  .initialize();
+
+const IOS_KEYCHAIN_ACCESS_GROUP = "group.org.streetwriters.notesnook";
+const IOS_KEYCHAIN_SERVICE_NAME = "org.streetwriters.notesnook";
+const KEYCHAIN_SERVER_DBKEY = "notesnook:db";
+
+const NOTESNOOK_APPLOCK_KEY_SALT = "kBwr1Kre86ebOZ8ThLu2OA";
+const NOTESNOOK_DB_KEY_SALT = "SNuzOcEK3amoqL0WvPeKqw";
+
+const DB_KEY_CIPHER = "databaseKeyCipher";
+const USER_KEY_CIPHER = "userKeyCipher";
+const APPLOCK_CIPHER = "applockCipher";
+
+const KEYSTORE_CONFIG = Platform.select({
+  ios: {
+    accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+    accessGroup: IOS_KEYCHAIN_ACCESS_GROUP,
+    service: IOS_KEYCHAIN_SERVICE_NAME
+  },
+  android: {}
+});
+
+function generatePassword() {
+  const length = 80;
+  //@ts-ignore
+  const crypto = window.crypto || window.msCrypto;
+  if (typeof crypto === "undefined") {
+    throw new Error(
+      "Crypto API is not supported. Please upgrade your web browser"
+    );
+  }
+  const charset =
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!@#$%^&+_{}[]():<>/?;";
+  const indexes = crypto.getRandomValues(new Uint32Array(length));
+  let secret = "";
+  for (const index of indexes) {
+    secret += charset[index % charset.length];
+  }
+  return secret;
+}
+
+export async function encryptDatabaseKeyWithPassword(appLockPassword: string) {
+  const key = (await getDatabaseKey()) as string;
+  const appLockCredentials = await Sodium.deriveKey(
+    appLockPassword,
+    NOTESNOOK_APPLOCK_KEY_SALT
+  );
+  const databaseKeyCipher = (await encrypt(appLockCredentials, key)) as Cipher;
+  MMKV.setMap(DB_KEY_CIPHER, databaseKeyCipher);
+  // We reset the database key from keychain once app lock password is set.
+  await Keychain.resetInternetCredentials(KEYCHAIN_SERVER_DBKEY);
+  return true;
+}
+
+export async function restoreDatabaseKeyToKeyChain(appLockPassword: string) {
+  const databaseKeyCipher: Cipher = CipherStorage.getMap(DB_KEY_CIPHER);
+  const databaseKey = (await decrypt(
+    {
+      password: appLockPassword
+    },
+    databaseKeyCipher
+  )) as string;
+
+  await Keychain.setInternetCredentials(
+    KEYCHAIN_SERVER_DBKEY,
+    "notesnook",
+    databaseKey,
+    KEYSTORE_CONFIG
+  );
+  MMKV.removeItem(DB_KEY_CIPHER);
+  return true;
+}
+
+export async function setAppLockVerificationCipher(appLockPassword: string) {
+  try {
+    const appLockCredentials = await Sodium.deriveKey(
+      appLockPassword,
+      NOTESNOOK_APPLOCK_KEY_SALT
+    );
+    const encrypted = (await encrypt(
+      appLockCredentials,
+      generatePassword()
+    )) as Cipher;
+    CipherStorage.setMap(APPLOCK_CIPHER, encrypted);
+    DatabaseLogger.info("setAppLockVerificationCipher");
+  } catch (e) {
+    DatabaseLogger.error(e);
+  }
+}
+
+export async function clearAppLockVerificationCipher() {
+  CipherStorage.removeItem(APPLOCK_CIPHER);
+}
+
+export async function validateAppLockPassword(appLockPassword: string) {
+  try {
+    const appLockCipher: Cipher = CipherStorage.getMap(APPLOCK_CIPHER);
+    if (!appLockCipher) return true;
+    const key = await Sodium.deriveKey(appLockPassword, appLockCipher.salt);
+    const decrypted = await decrypt(key, appLockCipher);
+
+    DatabaseLogger.info(
+      `validateAppLockPassword: ${typeof decrypted === "string"}`
+    );
+    return typeof decrypted === "string";
+  } catch (e) {
+    DatabaseLogger.error(e);
+    return false;
+  }
+}
+
+let DB_KEY: string | undefined;
+export function clearDatabaseKey() {
+  DB_KEY = undefined;
+  DatabaseLogger.info("Cleared database key");
+}
+
+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;
+  }
+
+  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;
+    }
+  }
+
+  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;
+
+    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");
+    }
+    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
+      )}`
+    );
+  }
+
+  return DB_KEY;
+}
+
+export async function deriveCryptoKeyFallback(data: SerializedKey) {
+  if (Platform.OS !== "ios") return;
+  try {
+    if (!data.password || !data.salt)
+      throw new Error(
+        "Invalid password and salt provided to deriveCryptoKeyFallback"
+      );
+
+    const credentials = await Sodium.deriveKeyFallback?.(
+      data.password,
+      data.salt
+    );
+
+    if (!credentials) return;
+
+    const userKeyCipher = (await encrypt(
+      {
+        key: (await getDatabaseKey()) as string,
+        salt: NOTESNOOK_DB_KEY_SALT
+      },
+      credentials.key as string
+    )) as Cipher<"base64">;
+    DatabaseLogger.info("User key fallback stored: ", {
+      userKeyCipher: !!userKeyCipher
+    });
+
+    // Store encrypted user key in MMKV
+    MMKV.setMap(USER_KEY_CIPHER, userKeyCipher);
+  } catch (e) {
+    DatabaseLogger.error(e);
+  }
+}
+
+export async function deriveCryptoKey(data: SerializedKey) {
+  try {
+    if (!data.password || !data.salt)
+      throw new Error("Invalid password and salt provided to deriveCryptoKey");
+
+    const credentials = (await Sodium.deriveKey(
+      data.password,
+      data.salt
+    )) as Password;
+    const userKeyCipher = (await encrypt(
+      {
+        key: (await getDatabaseKey()) as string,
+        salt: NOTESNOOK_DB_KEY_SALT
+      },
+      credentials.key as string
+    )) as Cipher<"base64">;
+    DatabaseLogger.info("User key stored: ", {
+      userKeyCipher: !!userKeyCipher
+    });
+
+    // Store encrypted user key in MMKV
+    MMKV.setMap(USER_KEY_CIPHER, userKeyCipher);
+  } catch (e) {
+    DatabaseLogger.error(e);
+  }
+}
+
+export async function getCryptoKey() {
+  try {
+    const keyCipher: Cipher = MMKV.getMap(USER_KEY_CIPHER);
+    if (!keyCipher) {
+      DatabaseLogger.info("User key cipher is null");
+      return undefined;
+    }
+
+    const key = await decrypt(
+      {
+        key: (await getDatabaseKey()) as string,
+        salt: keyCipher.salt
+      },
+      keyCipher
+    );
+
+    return key;
+  } catch (e) {
+    DatabaseLogger.error(e);
+  }
+}
+
+export async function removeCryptoKey() {
+  try {
+    MMKV.removeItem(USER_KEY_CIPHER);
+    await Keychain.resetInternetCredentials("notesnook");
+    return true;
+  } catch (e) {
+    DatabaseLogger.error(e);
+  }
+}
+
+export async function getRandomBytes(length: number) {
+  return await generateSecureRandom(length);
+}
+
+export async function hash(
+  password: string,
+  email: string,
+  options?: { usesFallback?: boolean }
+) {
+  DatabaseLogger.log(`Hashing password: fallback: ${options?.usesFallback}`);
+
+  if (options?.usesFallback && Platform.OS !== "ios") {
+    return "";
+  }
+
+  return (
+    options?.usesFallback
+      ? await Sodium.hashPasswordFallback?.(password, email)
+      : await Sodium.hashPassword(password, email)
+  ) as string;
+}
+
+export async function generateCryptoKey(password: string, salt?: string) {
+  return Sodium.deriveKey(password, salt) as Promise<SerializedKey>;
+}
+
+export async function generateCryptoKeyFallback(
+  password: string,
+  salt?: string
+): Promise<SerializedKey> {
+  return Sodium.deriveKeyFallback?.(
+    password,
+    salt as string
+  ) as Promise<SerializedKey>;
+}
+
+export function getAlgorithm(base64Variant: number) {
+  return `xcha-argon2i13-${base64Variant}`;
+}
+
+export async function decrypt(password: SerializedKey, data: Cipher<"base64">) {
+  const _data = { ...data };
+  _data.output = "plain";
+
+  if (!password.salt) password.salt = data.salt;
+
+  if (Platform.OS === "ios" && !password.key && password.password) {
+    const key = await Sodium.deriveKey(password.password, password.salt);
+    try {
+      return await Sodium.decrypt(key, _data);
+    } catch (e) {
+      const fallbackKey = await Sodium.deriveKeyFallback?.(
+        password.password,
+        password.salt
+      );
+      if (Platform.OS === "ios" && fallbackKey) {
+        DatabaseLogger.info("Using fallback key for decryption");
+      }
+      if (fallbackKey) {
+        return await Sodium.decrypt(fallbackKey, _data);
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return await Sodium.decrypt(password, _data);
+}
+
+export async function decryptMulti(
+  password: Password,
+  data: Cipher<"base64">[]
+) {
+  data = data.map((d) => {
+    d.output = "plain";
+    return d;
+  });
+
+  if (data.length && !password.salt) {
+    password.salt = data[0].salt;
+  }
+
+  if (Platform.OS === "ios" && !password.key && password.password) {
+    const key = await Sodium.deriveKey(password.password, password.salt);
+    try {
+      return await Sodium.decryptMulti(key, data);
+    } catch (e) {
+      const fallbackKey = await Sodium.deriveKeyFallback?.(
+        password.password,
+        password.salt as string
+      );
+      if (Platform.OS === "ios" && fallbackKey) {
+        DatabaseLogger.info("Using fallback key for decryption");
+      }
+      if (fallbackKey) {
+        return await Sodium.decryptMulti(fallbackKey, data);
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return await Sodium.decryptMulti(password, data);
+}
+
+export function parseAlgorithm(alg: string) {
+  if (!alg) return {};
+  const [enc, kdf, compressed, compressionAlg, base64variant] = alg.split("-");
+  return {
+    encryptionAlgorithm: enc,
+    kdfAlgorithm: kdf,
+    compressionAlgorithm: compressionAlg,
+    isCompress: compressed === "1",
+    base64_variant: base64variant
+  };
+}
+
+export async function encrypt(password: SerializedKey, plainText: string) {
+  const result = await Sodium.encrypt<"base64">(password, {
+    type: "plain",
+    data: plainText
+  });
+
+  return {
+    ...result,
+    alg: getAlgorithm(7)
+  };
+}
+
+export async function encryptMulti(
+  password: SerializedKey,
+  plainText: string[]
+) {
+  const results = await Sodium.encryptMulti<"base64">(
+    password,
+    plainText.map((item) => ({
+      type: "plain",
+      data: item
+    }))
+  );
+
+  return !results
+    ? []
+    : results.map((result) => ({
+        ...result,
+        alg: getAlgorithm(7)
+      }));
+}

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

@@ -16,48 +16,50 @@ 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 "./logger";
 import { database } from "@notesnook/common";
-import { logger as dbLogger } from "@notesnook/core";
-import { Platform } from "react-native";
-import * as Gzip from "react-native-gzip";
-import EventSource from "../../utils/sse/even-source-ios";
-import AndroidEventSource from "../../utils/sse/event-source";
+import { logger as dbLogger, ICompressor } from "@notesnook/core";
+import { strings } from "@notesnook/intl";
 import {
   SqliteAdapter,
   SqliteIntrospector,
   SqliteQueryCompiler
 } from "@streetwriters/kysely";
-import filesystem from "../filesystem";
-import Storage from "./storage";
-import { RNSqliteDriver } from "./sqlite.kysely";
-import { getDatabaseKey } from "./encryption";
+import { Platform } from "react-native";
+import * as Gzip from "react-native-gzip";
 import SettingsService from "../../services/settings";
-import { strings } from "@notesnook/intl";
+import EventSource from "../../utils/sse/even-source-ios";
+import AndroidEventSource from "../../utils/sse/event-source";
+import { FileStorage } from "../filesystem";
+import { getDatabaseKey } from "./encryption";
+import "./logger";
+import { RNSqliteDriver } from "./sqlite.kysely";
+import { Storage } from "./storage";
 
-export async function setupDatabase(password) {
+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",
     SSE_HOST: "https://events.streetwriters.co",
     SUBSCRIPTIONS_HOST: "https://subscriptions.streetwriters.co",
     ISSUES_HOST: "https://issues.streetwriters.co",
+    MONOGRAPH_HOST: "https://monogr.ph",
     ...(SettingsService.getProperty("serverUrls") || {})
   });
 
   database.setup({
     storage: Storage,
-    eventsource: Platform.OS === "ios" ? EventSource : AndroidEventSource,
-    fs: filesystem,
-    compressor: () => ({
-      compress: Gzip.deflate,
-      decompress: Gzip.inflate
-    }),
+    eventsource: (Platform.OS === "ios"
+      ? EventSource
+      : AndroidEventSource) as any,
+    fs: FileStorage,
+    compressor: async () =>
+      ({
+        compress: Gzip.deflate,
+        decompress: Gzip.inflate
+      } as ICompressor),
     batchSize: 100,
     sqliteOptions: {
       dialect: (name) => ({

apps/mobile/app/common/database/sqlite.kysely.ts

@@ -26,7 +26,7 @@ import { CompiledQuery } from "@streetwriters/kysely";
 import { QuickSQLiteConnection, open } from "react-native-quick-sqlite";
 import { strings } from "@notesnook/intl";
 
-type Config = { dbName: string; async: boolean; location: string };
+type Config = { dbName: string; async: boolean; location?: string };
 
 export class RNSqliteDriver implements Driver {
   private connection?: DatabaseConnection;

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

@@ -16,58 +16,52 @@ 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 { Platform } from "react-native";
-import RNFetchBlob from "react-native-blob-util";
+import { IStorage } from "@notesnook/core";
+import { MMKVInstance } from "react-native-mmkv-storage";
 import {
   decrypt,
   decryptMulti,
   deriveCryptoKey,
+  deriveCryptoKeyFallback,
   encrypt,
   encryptMulti,
   generateCryptoKey,
   getCryptoKey,
-  getRandomBytes,
   hash,
-  removeCryptoKey
+  generateCryptoKeyFallback
 } from "./encryption";
 import { MMKV } from "./mmkv";
 
 export class KV {
-  /**
-   * @type {typeof MMKV}
-   */
-  storage = null;
-  constructor(storage) {
+  storage: MMKVInstance;
+  constructor(storage: MMKVInstance) {
     this.storage = storage;
   }
-  async read(key) {
-    if (!key) return null;
-    let data = this.storage.getString(key);
-    if (!data) return null;
+
+  async read<T>(key: string, isArray?: boolean) {
+    if (!key) return undefined;
+    const data = this.storage.getString(key);
+    if (!data) return undefined;
     try {
-      let parse = JSON.parse(data);
-      return parse;
+      return JSON.parse(data) as T;
     } catch (e) {
-      return data;
+      return data as T;
     }
   }
 
-  async write(key, data) {
+  async write<T>(key: string, data: T) {
     this.storage.setString(
       key,
       typeof data === "string" ? data : JSON.stringify(data)
     );
-
-    return true;
   }
 
-  async readMulti(keys) {
+  async readMulti<T>(keys: string[]) {
     if (keys.length <= 0) {
       return [];
     } else {
       try {
-        let data = await this.storage.getMultipleItemsAsync(
+        const data = await this.storage.getMultipleItemsAsync<any>(
           keys.slice(),
           "string"
         );
@@ -79,24 +73,24 @@ export class KV {
             obj = value;
           }
           return [key, obj];
-        });
+        }) as [string, T][];
       } catch (e) {
-        console.log(e);
+        return [];
       }
     }
   }
 
-  async remove(key) {
-    return this.storage.removeItem(key);
+  async remove(key: string) {
+    this.storage.removeItem(key);
   }
 
-  async removeMulti(keys) {
-    if (!keys) return true;
-    return this.storage.removeItems(keys);
+  async removeMulti(keys: string[]) {
+    if (!keys) return;
+    this.storage.removeItems(keys);
   }
 
   async clear() {
-    return this.storage.clearStore();
+    this.storage.clearStore();
   }
 
   async getAllKeys() {
@@ -113,54 +107,46 @@ export class KV {
     return keys;
   }
 
-  async writeMulti(items) {
-    return this.storage.setMultipleItemsAsync(items, "object");
+  async writeMulti(items: [string, any][]) {
+    await this.storage.setMultipleItemsAsync(items, "object");
   }
 }
 
 const DefaultStorage = new KV(MMKV);
 
-async function requestPermission() {
-  if (Platform.OS === "ios") return true;
-  return true;
-}
-async function checkAndCreateDir(path) {
-  let dir =
-    Platform.OS === "ios"
-      ? RNFetchBlob.fs.dirs.DocumentDir + path
-      : RNFetchBlob.fs.dirs.SDCardDir + "/Notesnook/" + path;
-
-  try {
-    let exists = await RNFetchBlob.fs.exists(dir);
-    let isDir = await RNFetchBlob.fs.isDir(dir);
-    if (!exists || !isDir) {
-      await RNFetchBlob.fs.mkdir(dir);
-    }
-  } catch (e) {
-    await RNFetchBlob.fs.mkdir(dir);
-  }
-  return dir;
-}
-
-export default {
-  read: (key) => DefaultStorage.read(key),
-  write: (key, value) => DefaultStorage.write(key, value),
-  readMulti: (keys) => DefaultStorage.readMulti(keys),
-  remove: (key) => DefaultStorage.remove(key),
-  clear: () => DefaultStorage.clear(),
-  getAllKeys: () => DefaultStorage.getAllKeys(),
-  writeMulti: (items) => DefaultStorage.writeMulti(items),
-  removeMulti: (keys) => DefaultStorage.removeMulti(keys),
+export const Storage: IStorage = {
+  write<T>(key: string, data: T): Promise<void> {
+    return DefaultStorage.write(key, data);
+  },
+  writeMulti<T>(entries: [string, T][]): Promise<void> {
+    return DefaultStorage.writeMulti(entries);
+  },
+  readMulti<T>(keys: string[]): Promise<[string, T][]> {
+    return DefaultStorage.readMulti(keys);
+  },
+  read<T>(key: string, isArray?: boolean): Promise<T | undefined> {
+    return DefaultStorage.read(key, isArray);
+  },
+  remove(key: string): Promise<void> {
+    return DefaultStorage.remove(key);
+  },
+  removeMulti(keys: string[]): Promise<void> {
+    return DefaultStorage.removeMulti(keys);
+  },
+  clear(): Promise<void> {
+    return DefaultStorage.clear();
+  },
+  getAllKeys(): Promise<string[]> {
+    return DefaultStorage.getAllKeys();
+  },
+  hash,
+  getCryptoKey,
   encrypt,
+  encryptMulti,
   decrypt,
   decryptMulti,
-  getRandomBytes,
-  checkAndCreateDir,
-  requestPermission,
   deriveCryptoKey,
-  getCryptoKey,
-  removeCryptoKey,
-  hash,
   generateCryptoKey,
-  encryptMulti
+  generateCryptoKeyFallback,
+  deriveCryptoKeyFallback
 };

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

@@ -27,13 +27,9 @@ 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,
@@ -55,10 +51,12 @@ export async function compressToBase64(path, type) {
           : response.uri,
         "base64"
       );
-      RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(console.log);
-      RNFetchBlob.fs
-        .unlink(response.uri.replace("file://", ""))
-        .catch(console.log);
+      RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(() => {
+        /* empty */
+      });
+      RNFetchBlob.fs.unlink(response.uri.replace("file://", "")).catch(() => {
+        /* empty */
+      });
 
       resolve(base64);
     });
@@ -80,6 +78,8 @@ export async function compressToFile(path, type) {
       onlyScaleDown: true
     }
   );
-  RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(console.log);
+  RNFetchBlob.fs.unlink(path.replace("file://", "")).catch(() => {
+    /* empty */
+  });
   return response.uri;
 }

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

@@ -16,7 +16,6 @@ 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 Sodium from "@ammarahmed/react-native-sodium";
 import { getFileNameWithExtension } from "@notesnook/core";
 import { strings } from "@notesnook/intl";
@@ -25,12 +24,12 @@ import { Platform } from "react-native";
 import RNFetchBlob from "react-native-blob-util";
 import * as ScopedStorage from "react-native-scoped-storage";
 import { subscribe, zip } from "react-native-zip-archive";
+import filesystem from ".";
 import { ShareComponent } from "../../components/sheets/export-notes/share";
-import { ToastManager, presentSheet } from "../../services/event-manager";
+import { presentSheet, ToastManager } from "../../services/event-manager";
 import { useAttachmentStore } from "../../stores/use-attachment-store";
 import { IOS_APPGROUPID } from "../../utils/constants";
 import { DatabaseLogger, db } from "../database";
-import Storage from "../database/storage";
 import { createCacheDir, exists } from "./io";
 import { cacheDir, copyFileAsync, releasePermissions } from "./utils";
 
@@ -51,23 +50,23 @@ export async function downloadAllAttachments() {
 /**
  * Downloads provided attachments to a .zip file
  * on user's device.
- * @param {string[]} attachments
+ * @param {string[]} attachmentIds
  * @param onProgress
  * @returns
  */
-export async function downloadAttachments(attachments) {
+export async function downloadAttachments(attachmentIds: string[]) {
   await createCacheDir();
-  if (!attachments || !attachments.length) return;
+  if (!attachmentIds || !attachmentIds.length) return;
   const groupId = `download-all-${Date.now()}`;
 
   let outputFolder;
   if (Platform.OS === "android") {
     // Ask the user to select a directory to store the file
-    let file = await ScopedStorage.openDocumentTree(true);
+    const file = await ScopedStorage.openDocumentTree(true);
     outputFolder = file.uri;
     if (!outputFolder) return;
   } else {
-    outputFolder = await Storage.checkAndCreateDir("/downloads/");
+    outputFolder = await filesystem.checkAndCreateDir("/downloads/");
   }
 
   // Create the folder to zip;
@@ -83,8 +82,10 @@ export async function downloadAttachments(attachments) {
   await RNFetchBlob.fs.mkdir(zipSourceFolder);
 
   const isCancelled = () => {
-    if (useAttachmentStore.getState().downloading[groupId]?.canceled) {
-      RNFetchBlob.fs.unlink(zipSourceFolder).catch(console.log);
+    if (useAttachmentStore.getState().downloading?.[groupId]?.canceled) {
+      RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
+        /* empty */
+      });
       useAttachmentStore.getState().setDownloading({
         groupId,
         current: 0,
@@ -97,19 +98,21 @@ export async function downloadAttachments(attachments) {
     }
   };
 
-  for (let i = 0; i < attachments.length; i++) {
+  for (let i = 0; i < attachmentIds.length; i++) {
     if (isCancelled()) return;
-    let attachment = await db.attachments.attachment(attachments[i]);
+    const attachment = await db.attachments.attachment(attachmentIds[i]);
+    if (!attachment) continue;
+
     const hash = attachment.hash;
     try {
       useAttachmentStore.getState().setDownloading({
         groupId: groupId,
         current: i + 1,
-        total: attachments.length,
+        total: attachmentIds.length,
         filename: attachment.hash
       });
       // Download to cache
-      let uri = await downloadAttachment(hash, false, {
+      const uri = await downloadAttachment(hash, false, {
         silent: true,
         cache: true,
         groupId: groupId
@@ -184,48 +187,58 @@ export async function downloadAttachments(attachments) {
     });
     releasePermissions(outputFolder);
     sub?.remove();
-    ToastManager.error(e, "Error zipping attachments");
+    ToastManager.error(e as Error, "Error zipping attachments");
   }
   // Remove source & zip file from cache.
-  RNFetchBlob.fs.unlink(zipSourceFolder).catch(console.log);
+  RNFetchBlob.fs.unlink(zipSourceFolder).catch(() => {
+    /* empty */
+  });
   if (Platform.OS === "android") {
-    RNFetchBlob.fs.unlink(zipOutputFile).catch(console.log);
+    RNFetchBlob.fs.unlink(zipOutputFile).catch(() => {
+      /* empty */
+    });
   }
 }
 
 export default async function downloadAttachment(
-  hash,
+  hashOrId: string,
   global = true,
-  options = {
-    silent: false,
-    cache: false,
-    throwError: false,
-    groupId: undefined,
-    base64: false,
-    text: false
+  options?: {
+    silent?: boolean;
+    cache?: boolean;
+    throwError?: boolean;
+    groupId?: string;
+    base64?: boolean;
+    text?: boolean;
   }
 ) {
   await createCacheDir();
 
-  let attachment = await db.attachments.attachment(hash);
+  const attachment = await db.attachments.attachment(hashOrId);
   if (!attachment) {
-    DatabaseLogger.log("Attachment not found");
+    DatabaseLogger.log("Attachment not found", {
+      hash: hashOrId
+    });
     return;
   }
 
-  let folder = {};
-  if (!options.cache) {
+  let folder: {
+    uri: string;
+  } | null = null;
+  if (!options?.cache) {
     if (Platform.OS === "android") {
       folder = await ScopedStorage.openDocumentTree();
       if (!folder) return;
     } else {
-      folder.uri = await Storage.checkAndCreateDir("/downloads/");
+      folder = {
+        uri: await filesystem.checkAndCreateDir("/downloads/")
+      };
     }
   }
 
   try {
     useAttachmentStore.getState().setDownloading({
-      groupId: options.groupId || attachment.hash,
+      groupId: options?.groupId || attachment.hash,
       current: 0,
       total: 1,
       filename: attachment.filename
@@ -234,13 +247,13 @@ export default async function downloadAttachment(
     await db
       .fs()
       .downloadFile(
-        options.groupId || attachment.hash,
+        options?.groupId || attachment.hash,
         attachment.hash,
         attachment.chunkSize
       );
 
     useAttachmentStore.getState().setDownloading({
-      groupId: options.groupId || attachment.hash,
+      groupId: options?.groupId || attachment.hash,
       current: 1,
       total: 1,
       filename: attachment.filename,
@@ -252,7 +265,7 @@ export default async function downloadAttachment(
       return;
     }
 
-    if (options.base64 || options.text) {
+    if (options?.base64 || options?.text) {
       DatabaseLogger.log(`Starting to decrypt... hash: ${attachment.hash}`);
       return await db.attachments.read(
         attachment.hash,
@@ -260,14 +273,16 @@ export default async function downloadAttachment(
       );
     }
 
-    let filename = await getFileNameWithExtension(
+    const filename = await getFileNameWithExtension(
       attachment.filename,
       attachment.mimeType
     );
 
-    let key = await db.attachments.decryptKey(attachment.key);
+    const key = await db.attachments.decryptKey(attachment.key);
 
-    let info = {
+    if (!key) return;
+
+    const info = {
       iv: attachment.iv,
       salt: attachment.salt,
       length: attachment.size,
@@ -275,18 +290,18 @@ export default async function downloadAttachment(
       hash: attachment.hash,
       hashType: attachment.hashType,
       mime: attachment.mimeType,
-      fileName: options.cache ? undefined : filename,
-      uri: options.cache ? undefined : folder.uri,
+      fileName: options?.cache ? undefined : filename,
+      uri: options?.cache ? undefined : folder?.uri,
       chunkSize: attachment.chunkSize,
       appGroupId: IOS_APPGROUPID
     };
     let fileUri = await Sodium.decryptFile(
       key,
       info,
-      options.cache ? "cache" : "file"
+      options?.cache ? "cache" : "file"
     );
 
-    if (!options.silent) {
+    if (!options?.silent) {
       ToastManager.show({
         heading: strings.network.downloadSuccess(),
         message: strings.network.fileDownloaded(filename),
@@ -294,15 +309,15 @@ export default async function downloadAttachment(
       });
     }
 
-    if (Platform.OS === "ios" && !options.cache) {
-      fileUri = folder.uri + `/${filename}`;
+    if (Platform.OS === "ios" && !options?.cache) {
+      fileUri = folder?.uri + `/${filename}`;
     }
-    if (!options.silent) {
+    if (!options?.silent) {
       presentSheet({
         title: strings.network.fileDownloaded(),
         paragraph: strings.fileSaved(filename, Platform.OS),
         icon: "download",
-        context: global ? null : attachment.hash,
+        context: global ? "global" : attachment.hash,
         component: <ShareComponent uri={fileUri} name={filename} padding={12} />
       });
     }
@@ -312,14 +327,18 @@ export default async function downloadAttachment(
     if (attachment.dateUploaded) {
       RNFetchBlob.fs
         .unlink(RNFetchBlob.fs.dirs.CacheDir + `/${attachment.hash}`)
-        .catch(console.log);
+        .catch(() => {
+          /* empty */
+        });
       RNFetchBlob.fs
         .unlink(RNFetchBlob.fs.dirs.CacheDir + `/${attachment.hash}_dcache`)
-        .catch(console.log);
+        .catch(() => {
+          /* empty */
+        });
     }
 
     useAttachmentStore.getState().setDownloading({
-      groupId: options.groupId || attachment.hash,
+      groupId: options?.groupId || attachment.hash,
       current: 0,
       total: 0,
       filename: attachment.filename,
@@ -327,7 +346,7 @@ export default async function downloadAttachment(
     });
     DatabaseLogger.error(e);
     useAttachmentStore.getState().remove(attachment.hash);
-    if (options.throwError) {
+    if (options?.throwError) {
       throw e;
     }
   }

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

@@ -17,6 +17,7 @@ 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 { RequestOptions } from "@notesnook/core";
 import { strings } from "@notesnook/intl";
 import NetInfo from "@react-native-community/netinfo";
 import RNFetchBlob from "react-native-blob-util";
@@ -26,7 +27,13 @@ import { DatabaseLogger, db } from "../database";
 import { createCacheDir, exists } from "./io";
 import { ABYTES, cacheDir, getUploadedFileSize, parseS3Error } from "./utils";
 
-export async function downloadFile(filename, requestOptions, cancelToken) {
+export async function downloadFile(
+  filename: string,
+  requestOptions: RequestOptions,
+  cancelToken: {
+    cancel: (reason?: string) => Promise<void>;
+  }
+) {
   if (!requestOptions) {
     DatabaseLogger.log(
       `Error downloading file: ${filename}, reason: No requestOptions`
@@ -36,9 +43,11 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
 
   DatabaseLogger.log(`Downloading ${filename}`);
   await createCacheDir();
-  let { url, headers, chunkSize } = requestOptions;
-  let tempFilePath = `${cacheDir}/${filename}_temp`;
-  let originalFilePath = `${cacheDir}/${filename}`;
+
+  const { url, headers, chunkSize } = requestOptions;
+  const tempFilePath = `${cacheDir}/${filename}_temp`;
+  const originalFilePath = `${cacheDir}/${filename}`;
+
   try {
     if (await exists(filename)) {
       DatabaseLogger.log(`File Exists already: ${filename}`);
@@ -46,6 +55,8 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
     }
 
     const attachment = await db.attachments.attachment(filename);
+    if (!attachment) return false;
+
     const size = await getUploadedFileSize(filename);
 
     if (size === -1) {
@@ -71,21 +82,21 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
       throw new Error(error);
     }
 
-    let res = await fetch(url, {
+    const resolveUrlResponse = await fetch(url, {
       method: "GET",
       headers
     });
 
-    if (!res.ok) {
+    if (!resolveUrlResponse.ok) {
       DatabaseLogger.log(
-        `Error downloading file: ${filename}, ${res.status}, ${res.statusText}, reason: Unable to resolve download url`
+        `Error downloading file: ${filename}, ${resolveUrlResponse.status}, ${resolveUrlResponse.statusText}, reason: Unable to resolve download url`
       );
       throw new Error(
-        `${res.status}: ${strings.failedToResolvedDownloadUrl()}`
+        `${resolveUrlResponse.status}: ${strings.failedToResolvedDownloadUrl()}`
       );
     }
 
-    const downloadUrl = await res.text();
+    const downloadUrl = await resolveUrlResponse.text();
 
     if (!downloadUrl) {
       DatabaseLogger.log(
@@ -95,12 +106,12 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
     }
 
     DatabaseLogger.log(`Download starting: ${filename}`);
-    let request = RNFetchBlob.config({
+    const request = RNFetchBlob.config({
       path: tempFilePath,
       IOSBackgroundTask: true,
       overwrite: true
     })
-      .fetch("GET", downloadUrl, null)
+      .fetch("GET", downloadUrl)
       .progress(async (recieved, total) => {
         useAttachmentStore
           .getState()
@@ -109,15 +120,16 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
         DatabaseLogger.log(`Downloading: ${filename}, ${recieved}/${total}`);
       });
 
-    cancelToken.cancel = () => {
+    cancelToken.cancel = async (reason) => {
       useAttachmentStore.getState().remove(filename);
       request.cancel();
-      RNFetchBlob.fs.unlink(tempFilePath).catch(console.log);
-      DatabaseLogger.log(`Download cancelled: ${filename}`);
+      RNFetchBlob.fs.unlink(tempFilePath).catch(() => {
+        /* empty */
+      });
+      DatabaseLogger.log(`Download cancelled: ${reason} ${filename}`);
     };
 
-    let response = await request;
-    console.log(response.info().headers);
+    const response = await request;
 
     const contentType =
       response.info().headers?.["content-type"] ||
@@ -128,11 +140,13 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
       throw new Error(`[${error.Code}] ${error.Message}`);
     }
 
-    let status = response.info().status;
+    const status = response.info().status;
     useAttachmentStore.getState().remove(filename);
 
-    if (exists(originalFilePath)) {
-      await RNFetchBlob.fs.unlink(originalFilePath).catch(console.log);
+    if (await exists(originalFilePath)) {
+      await RNFetchBlob.fs.unlink(originalFilePath).catch(() => {
+        /* empty */
+      });
     }
 
     await RNFetchBlob.fs.mv(tempFilePath, originalFilePath);
@@ -143,11 +157,14 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
 
     return status >= 200 && status < 300;
   } catch (e) {
-    if (e.message !== "canceled" && !e.message.includes("NoSuchKey")) {
+    if (
+      (e as Error).message !== "canceled" &&
+      !(e as Error).message.includes("NoSuchKey")
+    ) {
       const toast = {
-        heading: strings.downloadError(),
-        message: e.message,
-        type: "error",
+        heading: strings.downloadError((e as Error).message),
+        message: (e as Error).message,
+        type: "error" as const,
         context: "global"
       };
       ToastManager.show(toast);
@@ -156,17 +173,20 @@ export async function downloadFile(filename, requestOptions, cancelToken) {
     }
 
     useAttachmentStore.getState().remove(filename);
-    RNFetchBlob.fs.unlink(tempFilePath).catch(console.log);
-    RNFetchBlob.fs.unlink(originalFilePath).catch(console.log);
-    DatabaseLogger.error(e, {
-      url,
-      headers
+    RNFetchBlob.fs.unlink(tempFilePath).catch(() => {
+      /* empty */
+    });
+    RNFetchBlob.fs.unlink(originalFilePath).catch(() => {
+      /* empty */
+    });
+    DatabaseLogger.error(e, "Download failed: ", {
+      url
     });
     return false;
   }
 }
 
-export async function checkAttachment(hash) {
+export async function checkAttachment(hash: string) {
   const internetState = await NetInfo.fetch();
   const isInternetReachable =
     internetState.isConnected && internetState.isInternetReachable;
@@ -176,7 +196,7 @@ export async function checkAttachment(hash) {
 
   try {
     const size = await getUploadedFileSize(hash);
-    console.log("File Size", size);
+
     if (size === -1) return { success: true };
 
     if (size === 0)
@@ -184,7 +204,7 @@ export async function checkAttachment(hash) {
         failed: `File length is 0. Please upload this file again from the attachment manager. (File hash: ${hash})`
       };
   } catch (e) {
-    return { failed: e?.message };
+    return { failed: (e as Error)?.message };
   }
   return { success: true };
 }

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

@@ -17,24 +17,41 @@ 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 { IFileStorage } from "@notesnook/core";
 import { checkAttachment, downloadFile } from "./download";
 import {
+  bulkExists,
+  clearCache,
   clearFileStorage,
+  deleteCacheFileByName,
+  deleteCacheFileByPath,
   deleteFile,
   exists,
-  readEncrypted,
-  writeEncryptedBase64,
+  getCacheSize,
   hashBase64,
+  readEncrypted,
+  writeEncryptedBase64
+} from "./io";
+import { uploadFile } from "./upload";
+import {
+  cancelable,
+  checkAndCreateDir,
+  getUploadedFileSize,
+  requestPermission
+} from "./utils";
+
+export default {
+  checkAttachment,
   clearCache,
   deleteCacheFileByName,
   deleteCacheFileByPath,
-  bulkExists,
-  getCacheSize
-} from "./io";
-import { uploadFile } from "./upload";
-import { cancelable, getUploadedFileSize } from "./utils";
+  getCacheSize,
+  requestPermission,
+  checkAndCreateDir,
+  getUploadedFileSize
+};
 
-export default {
+export const FileStorage: IFileStorage = {
   readEncrypted,
   writeEncryptedBase64,
   hashBase64,
@@ -44,10 +61,5 @@ export default {
   exists,
   clearFileStorage,
   getUploadedFileSize,
-  checkAttachment,
-  clearCache,
-  deleteCacheFileByName,
-  deleteCacheFileByPath,
-  bulkExists,
-  getCacheSize
+  bulkExists
 };

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

@@ -18,6 +18,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import Sodium from "@ammarahmed/react-native-sodium";
+import {
+  FileEncryptionMetadataWithHash,
+  FileEncryptionMetadataWithOutputType,
+  Output,
+  RequestOptions
+} from "@notesnook/core";
+import { DataFormat, SerializedKey } from "@notesnook/crypto";
 import { Platform } from "react-native";
 import RNFetchBlob from "react-native-blob-util";
 import { eSendEvent } from "../../services/event-manager";
@@ -25,17 +32,21 @@ import { IOS_APPGROUPID } from "../../utils/constants";
 import { DatabaseLogger, db } from "../database";
 import { ABYTES, cacheDir, cacheDirOld, getRandomId } from "./utils";
 
-export async function readEncrypted(filename, key, cipherData) {
+export async function readEncrypted<TOutputFormat extends DataFormat>(
+  filename: string,
+  key: SerializedKey,
+  cipherData: FileEncryptionMetadataWithOutputType<TOutputFormat>
+) {
   await migrateFilesFromCache();
   DatabaseLogger.log("Read encrypted file...");
-  let path = `${cacheDir}/${filename}`;
+  const path = `${cacheDir}/${filename}`;
 
   try {
     if (!(await exists(filename))) {
-      return false;
+      return;
     }
 
-    let output = await Sodium.decryptFile(
+    const output = await Sodium.decryptFile(
       key,
       {
         ...cipherData,
@@ -47,15 +58,16 @@ export async function readEncrypted(filename, key, cipherData) {
 
     DatabaseLogger.log("File decrypted...");
 
-    return output;
+    return output as Output<TOutputFormat>;
   } catch (e) {
-    RNFetchBlob.fs.unlink(path).catch(console.log);
+    RNFetchBlob.fs.unlink(path).catch(() => {
+      /* empty */
+    });
     DatabaseLogger.error(e);
-    return false;
   }
 }
 
-export async function hashBase64(data) {
+export async function hashBase64(data: string) {
   const hash = await Sodium.hashFile({
     type: "base64",
     data,
@@ -67,61 +79,79 @@ export async function hashBase64(data) {
   };
 }
 
-export async function writeEncryptedBase64(data, key) {
+export async function writeEncryptedBase64(
+  data: string,
+  encryptionKey: SerializedKey,
+  mimeType: string
+): Promise<FileEncryptionMetadataWithHash> {
   await createCacheDir();
-  let filepath = cacheDir + `/${getRandomId("imagecache_")}`;
+  const filepath = cacheDir + `/${getRandomId("imagecache_")}`;
   await RNFetchBlob.fs.writeFile(filepath, data, "base64");
-  let output = await Sodium.encryptFile(key, {
+  const output = await Sodium.encryptFile(encryptionKey, {
     uri: Platform.OS === "ios" ? filepath : "file://" + filepath,
     type: "url"
   });
-  RNFetchBlob.fs.unlink(filepath).catch(console.log);
-  console.log("encrypted file output: ", output);
-  output.size = output.length;
-  delete output.length;
+
+  RNFetchBlob.fs.unlink(filepath).catch(() => {
+    /* empty */
+  });
+
   return {
     ...output,
     alg: "xcha-stream"
   };
 }
 
-export async function deleteFile(filename, data) {
+export async function deleteFile(
+  filename: string,
+  requestOptions?: RequestOptions
+): Promise<boolean> {
   await createCacheDir();
-  let delFilePath = cacheDir + `/${filename}`;
-  if (!data) {
-    if (!filename) return;
-    RNFetchBlob.fs.unlink(delFilePath).catch(console.log);
+  const localFilePath = cacheDir + `/${filename}`;
+  if (!requestOptions) {
+    RNFetchBlob.fs.unlink(localFilePath).catch(() => {
+      /* empty */
+    });
     return true;
   }
 
-  let { url, headers } = data;
+  const { url, headers } = requestOptions;
+
   try {
-    let response = await RNFetchBlob.fetch("DELETE", url, headers);
-    let status = response.info().status;
-    let ok = status >= 200 && status < 300;
+    const response = await RNFetchBlob.fetch("DELETE", url, headers);
+    const status = response.info().status;
+    const ok = status >= 200 && status < 300;
     if (ok) {
-      RNFetchBlob.fs.unlink(delFilePath).catch(console.log);
+      RNFetchBlob.fs.unlink(localFilePath).catch(() => {
+        /* empty */
+      });
     }
     return ok;
   } catch (e) {
-    console.log("delete file: ", e, url, headers);
+    DatabaseLogger.error(e, "Delete file", {
+      url: url
+    });
     return false;
   }
 }
 
 export async function clearFileStorage() {
   try {
-    let files = await RNFetchBlob.fs.ls(cacheDir);
-    let oldCache = await RNFetchBlob.fs.ls(cacheDirOld);
+    const files = await RNFetchBlob.fs.ls(cacheDir);
+    const oldCache = await RNFetchBlob.fs.ls(cacheDirOld);
 
-    for (let file of files) {
-      await RNFetchBlob.fs.unlink(cacheDir + `/${file}`).catch(console.log);
+    for (const file of files) {
+      await RNFetchBlob.fs.unlink(cacheDir + `/${file}`).catch(() => {
+        /* empty */
+      });
     }
-    for (let file of oldCache) {
-      await RNFetchBlob.fs.unlink(cacheDirOld + `/${file}`).catch(console.log);
+    for (const file of oldCache) {
+      await RNFetchBlob.fs.unlink(cacheDirOld + `/${file}`).catch(() => {
+        /* empty */
+      });
     }
   } catch (e) {
-    console.log("clearFileStorage", e);
+    DatabaseLogger.error(e, "clearFileStorage");
   }
 }
 
@@ -142,62 +172,71 @@ export async function migrateFilesFromCache() {
     const migratedFilesPath = cacheDir + "/.migrated_1";
     const migrated = await RNFetchBlob.fs.exists(migratedFilesPath);
     if (migrated) {
-      console.log("Files migrated already");
       return;
     }
 
-    let files = await RNFetchBlob.fs.ls(cacheDir);
-    console.log("Files to migrate:", files.join(","));
+    const files = await RNFetchBlob.fs.ls(cacheDir);
 
-    let oldCache = await RNFetchBlob.fs.ls(cacheDirOld);
-    for (let file of oldCache) {
+    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(console.log);
-      console.log("Moved", file);
+        .catch(() => {
+          /* empty */
+        });
     }
     await RNFetchBlob.fs.createFile(migratedFilesPath, "1", "utf8");
   } catch (e) {
-    console.log("migrateFilesFromCache", e);
+    DatabaseLogger.error(e, "migrateFilesFromCache");
   }
 }
 
 export async function clearCache() {
-  await RNFetchBlob.fs.unlink(cacheDir).catch(console.log);
+  await RNFetchBlob.fs.unlink(cacheDir).catch(() => {
+    /* empty */
+  });
   await createCacheDir();
   eSendEvent("cache-cleared");
 }
 
-export async function deleteCacheFileByPath(path) {
-  await RNFetchBlob.fs.unlink(path).catch(console.log);
+export async function deleteCacheFileByPath(path: string) {
+  await RNFetchBlob.fs.unlink(path).catch(() => {
+    /* empty */
+  });
 }
 
-export async function deleteCacheFileByName(name) {
+export async function deleteCacheFileByName(name: string) {
   const iosAppGroup =
     Platform.OS === "ios"
-      ? await RNFetchBlob.fs.pathForAppGroup(IOS_APPGROUPID)
+      ? await (RNFetchBlob.fs as any).pathForAppGroup(IOS_APPGROUPID)
       : null;
   const appGroupPath = `${iosAppGroup}/${name}`;
-  await RNFetchBlob.fs.unlink(appGroupPath).catch(console.log);
-  await RNFetchBlob.fs.unlink(`${cacheDir}/${name}`).catch(console.log);
+  await RNFetchBlob.fs.unlink(appGroupPath).catch(() => {
+    /* empty */
+  });
+  await RNFetchBlob.fs.unlink(`${cacheDir}/${name}`).catch(() => {
+    /* empty */
+  });
 }
 
 export async function deleteDCacheFiles() {
   const files = await RNFetchBlob.fs.ls(cacheDir);
   for (const file of files) {
-    if (file.includes("_dcache")) {
-      await RNFetchBlob.fs.unlink(file).catch(console.log);
+    if (file.includes("_dcache") || file.startsWith("NN_")) {
+      await RNFetchBlob.fs.unlink(file).catch(() => {
+        /* empty */
+      });
     }
   }
 }
 
-export async function exists(filename) {
-  let path = `${cacheDir}/${filename}`;
+export async function exists(filename: string) {
+  const path = `${cacheDir}/${filename}`;
 
   const iosAppGroup =
     Platform.OS === "ios"
-      ? await RNFetchBlob.fs.pathForAppGroup(IOS_APPGROUPID)
+      ? await (RNFetchBlob.fs as any).pathForAppGroup(IOS_APPGROUPID)
       : null;
   const appGroupPath = `${iosAppGroup}/${filename}`;
 
@@ -211,6 +250,7 @@ export async function exists(filename) {
 
   if (exists || existsInAppGroup) {
     const attachment = await db.attachments.attachment(filename);
+    if (!attachment) return false;
     const totalChunks = Math.ceil(attachment.size / attachment.chunkSize);
     const totalAbytes = totalChunks * ABYTES;
     const expectedFileSize = attachment.size + totalAbytes;
@@ -225,7 +265,9 @@ export async function exists(filename) {
       );
       RNFetchBlob.fs
         .unlink(existsInAppGroup ? appGroupPath : path)
-        .catch(console.log);
+        .catch(() => {
+          /* empty */
+        });
       return false;
     }
 
@@ -234,7 +276,7 @@ export async function exists(filename) {
   return exists;
 }
 
-export async function bulkExists(files) {
+export async function bulkExists(files: string[]) {
   try {
     await createCacheDir();
     const cacheFiles = await RNFetchBlob.fs.ls(cacheDir);
@@ -243,7 +285,7 @@ export async function bulkExists(files) {
     if (Platform.OS === "ios") {
       const iosAppGroup =
         Platform.OS === "ios"
-          ? await RNFetchBlob.fs.pathForAppGroup(IOS_APPGROUPID)
+          ? await (RNFetchBlob.fs as any).pathForAppGroup(IOS_APPGROUPID)
           : null;
       const appGroupFiles = await RNFetchBlob.fs.ls(iosAppGroup);
       missingFiles = missingFiles.filter(
@@ -261,9 +303,9 @@ 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((s) => {
-    total += parseInt(s.size);
+
+  stat.forEach((file) => {
+    total += parseInt(file.size as unknown as string);
   });
   return total;
 }

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

@@ -17,6 +17,7 @@ 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 { RequestOptions } from "@notesnook/core";
 import { Platform } from "react-native";
 import RNFetchBlob from "react-native-blob-util";
 import { ToastManager } from "../../services/event-manager";
@@ -24,11 +25,22 @@ import { useAttachmentStore } from "../../stores/use-attachment-store";
 import { IOS_APPGROUPID } from "../../utils/constants";
 import { DatabaseLogger, db } from "../database";
 import { createCacheDir } from "./io";
-import { cacheDir, checkUpload, getUploadedFileSize } from "./utils";
+import {
+  cacheDir,
+  checkUpload,
+  FileSizeResult,
+  getUploadedFileSize
+} from "./utils";
 
-export async function uploadFile(filename, requestOptions, cancelToken) {
+export async function uploadFile(
+  filename: string,
+  requestOptions: RequestOptions,
+  cancelToken: {
+    cancel: (reason?: string) => Promise<void>;
+  }
+) {
   if (!requestOptions) return false;
-  let { url, headers } = requestOptions;
+  const { url, headers } = requestOptions;
   await createCacheDir();
   DatabaseLogger.info(`Preparing to upload file: ${filename}`);
 
@@ -39,7 +51,7 @@ export async function uploadFile(filename, requestOptions, cancelToken) {
     if (!exists && Platform.OS === "ios") {
       const iosAppGroup =
         Platform.OS === "ios"
-          ? await RNFetchBlob.fs.pathForAppGroup(IOS_APPGROUPID)
+          ? await (RNFetchBlob.fs as any).pathForAppGroup(IOS_APPGROUPID)
           : null;
       const appGroupPath = `${iosAppGroup}/${filename}`;
       filePath = appGroupPath;
@@ -54,14 +66,15 @@ export async function uploadFile(filename, requestOptions, cancelToken) {
 
     const fileSize = (await RNFetchBlob.fs.stat(filePath)).size;
 
-    let remoteFileSize = await getUploadedFileSize(filename);
-    if (remoteFileSize === -1) return false;
-    if (remoteFileSize > 0 && remoteFileSize === fileSize) {
+    const remoteFileSize = await getUploadedFileSize(filename);
+    if (remoteFileSize === FileSizeResult.Error) return false;
+
+    if (remoteFileSize > FileSizeResult.Empty && remoteFileSize === fileSize) {
       DatabaseLogger.log(`File ${filename} is already uploaded.`);
       return true;
     }
 
-    let uploadUrlResponse = await fetch(url, {
+    const uploadUrlResponse = await fetch(url, {
       method: "PUT",
       headers
     });
@@ -78,7 +91,8 @@ export async function uploadFile(filename, requestOptions, cancelToken) {
 
     DatabaseLogger.info(`Starting upload: ${filename}`);
 
-    let uploadRequest = RNFetchBlob.config({
+    const uploadRequest = RNFetchBlob.config({
+      //@ts-ignore
       IOSBackgroundTask: !globalThis["IS_SHARE_EXTENSION"]
     })
       .fetch(
@@ -98,14 +112,14 @@ export async function uploadFile(filename, requestOptions, cancelToken) {
         );
       });
 
-    cancelToken.cancel = () => {
+    cancelToken.cancel = async () => {
       useAttachmentStore.getState().remove(filename);
       uploadRequest.cancel();
     };
 
-    let uploadResponse = await uploadRequest;
-    let status = uploadResponse.info().status;
-    let uploaded = status >= 200 && status < 300;
+    const uploadResponse = await uploadRequest;
+    const status = uploadResponse.info().status;
+    const uploaded = status >= 200 && status < 300;
 
     useAttachmentStore.getState().remove(filename);
 
@@ -118,12 +132,13 @@ export async function uploadFile(filename, requestOptions, cancelToken) {
       );
     }
     const attachment = await db.attachments.attachment(filename);
+    if (!attachment) return false;
     await checkUpload(filename, requestOptions.chunkSize, attachment.size);
     DatabaseLogger.info(`File upload status: ${filename}, ${status}`);
     return uploaded;
   } catch (e) {
     useAttachmentStore.getState().remove(filename);
-    ToastManager.error(e, "File upload failed");
+    ToastManager.error(e as Error, "File upload failed");
     DatabaseLogger.error(e, "File upload failed", {
       filename
     });

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

@@ -17,11 +17,11 @@ 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 { hosts, RequestOptions } from "@notesnook/core";
 import { Platform } from "react-native";
 import RNFetchBlob from "react-native-blob-util";
 import * as ScopedStorage from "react-native-scoped-storage";
 import { DatabaseLogger, db } from "../database";
-import { hosts } from "@notesnook/core";
 
 export const ABYTES = 17;
 export const cacheDirOld = RNFetchBlob.fs.dirs.CacheDir;
@@ -31,18 +31,13 @@ export const cacheDir =
     ? RNFetchBlob.fs.dirs.LibraryDir + "/.cache"
     : RNFetchBlob.fs.dirs.DocumentDir + "/.cache";
 
-export function getRandomId(prefix) {
+export function getRandomId(prefix: string) {
   return Math.random()
     .toString(36)
     .replace("0.", prefix || "");
 }
 
-/**
- *
- * @param {string | undefined} data
- * @returns
- */
-export function parseS3Error(data) {
+export function parseS3Error(data?: string) {
   const xml = typeof data === "string" ? data : null;
 
   const error = {
@@ -70,11 +65,19 @@ export function parseS3Error(data) {
   }
 }
 
-export function cancelable(operation) {
+export function cancelable(
+  operation: (
+    filename: string,
+    requestOptions: RequestOptions,
+    cancelToken: {
+      cancel: (reason?: string) => Promise<void>;
+    }
+  ) => Promise<boolean>
+) {
   const cancelToken = {
-    cancel: () => {}
+    cancel: async (reason?: string) => {}
   };
-  return (filename, requestOptions) => {
+  return (filename: string, requestOptions: RequestOptions) => {
     return {
       execute: () => operation(filename, requestOptions, cancelToken),
       cancel: async () => {
@@ -84,29 +87,35 @@ export function cancelable(operation) {
   };
 }
 
-export function copyFileAsync(source, dest) {
+export function copyFileAsync(source: string, dest: string) {
   return new Promise((resolve, reject) => {
-    ScopedStorage.copyFile(source, dest, (e, r) => {
+    //@ts-ignore
+    ScopedStorage.copyFile(source, dest, (e: any, r: any) => {
       if (e) {
         reject(e);
         return;
       }
-      resolve();
+      resolve(true);
     });
   });
 }
 
-export async function releasePermissions(path) {
+export async function releasePermissions(path: string) {
   if (Platform.OS === "ios") return;
   const uris = await ScopedStorage.getPersistedUriPermissions();
-  for (let uri of uris) {
+  for (const uri of uris) {
     if (path.startsWith(uri)) {
       await ScopedStorage.releasePersistableUriPermission(uri);
     }
   }
 }
 
-export async function getUploadedFileSize(hash) {
+export const FileSizeResult = {
+  Empty: 0,
+  Error: -1
+};
+
+export async function getUploadedFileSize(hash: string) {
   try {
     const url = `${hosts.API_HOST}/s3?name=${hash}`;
     const token = await db.tokenManager.getAccessToken();
@@ -115,16 +124,20 @@ export async function getUploadedFileSize(hash) {
       headers: { Authorization: `Bearer ${token}` }
     });
     const contentLength = parseInt(
-      attachmentInfo.headers?.get("content-length")
+      attachmentInfo.headers?.get("content-length") || "0"
     );
-    return isNaN(contentLength) ? 0 : contentLength;
+    return isNaN(contentLength) ? FileSizeResult.Empty : contentLength;
   } catch (e) {
     DatabaseLogger.error(e);
-    return -1;
+    return FileSizeResult.Error;
   }
 }
 
-export async function checkUpload(filename, chunkSize, expectedSize) {
+export async function checkUpload(
+  filename: string,
+  chunkSize: number,
+  expectedSize: number
+) {
   const size = await getUploadedFileSize(filename);
   const totalChunks = Math.ceil(size / chunkSize);
   const decryptedLength = size - totalChunks * ABYTES;
@@ -138,3 +151,25 @@ export async function checkUpload(filename, chunkSize, expectedSize) {
       : undefined;
   if (error) throw new Error(error);
 }
+
+export async function requestPermission() {
+  if (Platform.OS === "ios") return true;
+  return true;
+}
+export async function checkAndCreateDir(path: string) {
+  const dir =
+    Platform.OS === "ios"
+      ? RNFetchBlob.fs.dirs.DocumentDir + path
+      : RNFetchBlob.fs.dirs.SDCardDir + "/Notesnook/" + path;
+
+  try {
+    const exists = await RNFetchBlob.fs.exists(dir);
+    const isDir = await RNFetchBlob.fs.isDir(dir);
+    if (!exists || !isDir) {
+      await RNFetchBlob.fs.mkdir(dir);
+    }
+  } catch (e) {
+    await RNFetchBlob.fs.mkdir(dir);
+  }
+  return dir;
+}

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

@@ -17,9 +17,7 @@ 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[]) {
-  console.log(`${new Date().toLocaleDateString()}::info::${context}:`, ...logs);
-}
+function info(context: string, ...logs: unknown[]) {}
 
 function error(context: string, ...logs: unknown[]) {
   console.log(

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

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

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

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

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

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

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

@@ -68,11 +68,15 @@ export const ChangePassword = () => {
     }
     setLoading(true);
     try {
-      const result = await BackupService.run(false, "change-password-dialog");
-      if (!result.error)
+      const result = await BackupService.run(
+        false,
+        "change-password-dialog",
+        "partial"
+      );
+      if (result.error) {
         throw new Error(strings.backupFailed() + `: ${result.error}`);
+      }
 
-      await db.user.clearSessions();
       await db.user.changePassword(oldPassword.current, password.current);
       ToastManager.show({
         heading: strings.passwordChangedSuccessfully(),

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

@@ -38,7 +38,7 @@ import { useAppState } from "../../hooks/use-app-state";
 
 export interface BaseDialogProps extends PropsWithChildren {
   animation?: "fade" | "none" | "slide" | undefined;
-  visible: boolean;
+  visible?: boolean;
   onRequestClose?: () => void;
   onShow?: () => void;
   premium?: boolean;
@@ -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,26 +86,20 @@ const BaseDialog = ({
   }, []);
 
   useEffect(() => {
-    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;
-              });
-            }
+    if (locked) {
+      setIntervalVisible(false);
+      lockEvents.current = true;
+      const unsub = useUserStore.subscribe((state) => {
+        if (!state.appLocked) {
+          setIntervalVisible(true);
+          unsub();
+          setTimeout(() => {
+            lockEvents.current = false;
           });
         }
-      }
+      });
     }
-  }, [appState]);
+  }, [locked]);
 
   const Wrapper = useSafeArea ? SafeAreaView : View;
 

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

@@ -179,6 +179,7 @@ const ColorPicker = ({
                   title: title.current,
                   colorCode: selectedColor
                 });
+                if (!id) return;
                 useRelationStore.getState().update();
                 useMenuStore.getState().setColorNotes();
                 setVisible(false);

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

@@ -307,9 +307,7 @@ const PDFPreview = () => {
                     password={password}
                     maxScale={6}
                     onError={onError}
-                    onPressLink={(uri) => {
-                      console.log(`Link pressed: ${uri}`);
-                    }}
+                    onPressLink={(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,7 +406,6 @@ 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();
@@ -460,7 +459,7 @@ export class VaultDialog extends Component {
   async _deleteNote() {
     try {
       await db.vault.remove(this.state.note.id, this.password);
-      await deleteItems([this.state.note.id], "note");
+      await deleteItems("note", [this.state.note.id]);
       this.close();
     } catch (e) {
       this._takeErrorAction(e);
@@ -543,7 +542,6 @@ 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() {
+  return function ErrorBoundary(props: any) {
     return (
       <ExceptionHandler component={name}>
-        <Element />
+        <Element {...props} />
       </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 } from "@notesnook/core";
+import { DataURL, getFileNameWithExtension } from "@notesnook/core";
 import type { ImageAttributes } from "@notesnook/editor";
 import { useThemeColors } from "@notesnook/theme";
 import React, { useEffect, useRef, useState } from "react";
@@ -34,6 +34,11 @@ 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");
 
@@ -41,6 +46,8 @@ 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);
@@ -73,16 +80,86 @@ const ImagePreview = () => {
         silent: true,
         cache: true
       });
-      const path = `${cacheDir}/${uri}`;
+
+      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 */
+      });
       setImage("file://" + path);
       setLoading(false);
     }, 100);
   };
 
-  const close = () => {
+  const close = React.useCallback(() => {
+    image &&
+      RNFetchBlob.fs.unlink(image.replace("file://", "")).catch(() => {
+        /* empty */
+      });
     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 && (
@@ -90,6 +167,7 @@ const ImagePreview = () => {
         background="black"
         animation="slide"
         visible={true}
+        useSafeArea={false}
         onRequestClose={close}
         transparent
       >
@@ -130,43 +208,25 @@ const ImagePreview = () => {
               />
             </View>
           ) : (
-            <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
-                }
-              ]}
-            />
+            <>
+              <ImageViewer
+                enableImageZoom={true}
+                renderIndicator={() => <></>}
+                enableSwipeDown
+                useNativeDriver
+                onSwipeDown={close}
+                saveToLocalByLongPress={false}
+                onClick={() => {
+                  setShowHeader(!showHeader);
+                }}
+                renderHeader={renderHeader}
+                imageUrls={[
+                  {
+                    url: image as string
+                  }
+                ]}
+              />
+            </>
           )}
         </View>
       </BaseDialog>

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

@@ -128,7 +128,6 @@ const Intro = ({ navigation }) => {
         style={{
           width: deviceMode !== "mobile" ? width / 2 : "100%",
           backgroundColor: colors.secondary.background,
-          marginBottom: 20,
           borderBottomWidth: 1,
           borderBottomColor: colors.primary.border,
           alignSelf: deviceMode !== "mobile" ? "center" : undefined,
@@ -138,7 +137,7 @@ const Intro = ({ navigation }) => {
           marginTop: deviceMode !== "mobile" ? 50 : null,
           paddingTop: insets.top + 10,
           paddingBottom: insets.top + 10,
-          minHeight: height * 0.7
+          minHeight: height * 0.7 - (insets.top + insets.bottom)
         }}
       >
         <SwiperFlatList

apps/mobile/app/components/list-items/headers/section-header.tsx

@@ -57,10 +57,7 @@ export const SectionHeader = React.memo<
   }: SectionHeaderProps) {
     const { colors } = useThemeColors();
     const { fontScale } = useWindowDimensions();
-    const groupBy =
-      strings.groupByStrings[
-        groupOptions.groupBy as keyof typeof strings.groupByStrings
-      ]?.();
+    const groupBy = strings.groupByStrings[groupOptions.groupBy]();
     const isCompactModeEnabled = useIsCompactModeEnabled(
       dataType as "note" | "notebook"
     );

apps/mobile/app/components/list/list-item.wrapper.tsx

@@ -153,9 +153,7 @@ export function ListItemWrapper(props: ListItemWrapperProps) {
           },
           items?.cacheItem(index) ? 100 : 0
         );
-      } catch (e) {
-        console.log("Error", e);
-      }
+      } catch (e) {}
     })();
   }, [index, items, refreshItem]);
 
@@ -297,7 +295,6 @@ function getDate(item: Item, groupType?: GroupingKey): number {
       groupType
         ? db.settings.getGroupOptions(groupType)
         : {
-            groupBy: "default",
             sortBy: "dateEdited",
             sortDirection: "desc"
           },

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

@@ -119,7 +119,6 @@ export const PricingPlans = ({
       setLoading(false);
     } catch (e) {
       setLoading(false);
-      console.log("error getting sku", e);
     }
   }, [promo?.promoCode]);
 
@@ -129,7 +128,10 @@ export const PricingPlans = ({
       if (code.startsWith("com.streetwriters.notesnook")) {
         skuId = code;
       } else {
-        skuId = await db.offers?.getCode(code.split(":")[0], Platform.OS);
+        skuId = await db.offers?.getCode(
+          code.split(":")[0],
+          Platform.OS as "ios" | "android"
+        );
       }
 
       const products = await PremiumService.getProducts();
@@ -168,7 +170,6 @@ export const PricingPlans = ({
       });
       return true;
     } catch (e) {
-      console.log("PROMOCODE ERROR:", code, e);
       return false;
     }
   };
@@ -228,7 +229,6 @@ 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,
-                      presistTab: true
+                      newTab: true
                     });
                     if (!DDS.isTab) {
                       tabBarRef.current?.goToPage(1);

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

@@ -18,6 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Item, ItemType, VirtualizedGrouping } from "@notesnook/core";
+import { strings } from "@notesnook/intl";
 import { useThemeColors } from "@notesnook/theme";
 import React, { useEffect, useRef } from "react";
 import {
@@ -46,7 +47,6 @@ import { MoveNotebookSheet } from "../sheets/move-notebook";
 import { Button } from "../ui/button";
 import { IconButton } from "../ui/icon-button";
 import Heading from "../ui/typography/heading";
-import { strings } from "@notesnook/intl";
 
 export const SelectionHeader = React.memo(
   ({
@@ -103,12 +103,11 @@ export const SelectionHeader = React.memo(
     const deleteItem = async () => {
       if (!type) return;
       presentDialog({
-        title: strings.doActions.delete[
-          type as keyof typeof strings.doActions.delete
-        ](selectedItemsList.length),
-        paragraph: strings.actionConfirmations.delete[
-          type as keyof typeof strings.doActions.delete
-        ](selectedItemsList.length),
+        title: strings.doActions.delete.unknown(type, selectedItemsList.length),
+        paragraph: strings.actionConfirmations.delete.unknown(
+          type,
+          selectedItemsList.length
+        ),
         positiveText: strings.delete(),
         negativeText: strings.cancel(),
         positivePress: async () => {
@@ -297,15 +296,35 @@ export const SelectionHeader = React.memo(
                 {
                   title: strings.moveToTrash(),
                   onPress: async () => {
-                    deleteItems(
-                      undefined,
-                      useSelectionStore.getState().selectionMode
-                    ).then(() => {
-                      useSelectionStore.getState().clearSelection();
-                      useSelectionStore.getState().setSelectionMode(undefined);
-                    });
+                    const selection = useSelectionStore.getState();
+                    if (!selection.selectionMode) return;
+                    await deleteItems(
+                      selection.selectionMode as ItemType,
+                      selection.selectedItemsList
+                    );
+                    selection.clearSelection();
+                    selection.setSelectionMode(undefined);
                   },
-                  visible: type !== "trash",
+                  visible: type === "note" || type === "notebook",
+                  icon: "delete"
+                },
+                {
+                  title: strings.doActions.delete.unknown(
+                    type!,
+                    selectedItemsList.length
+                  ),
+                  onPress: async () => {
+                    const selection = useSelectionStore.getState();
+                    if (!selection.selectionMode) return;
+                    await deleteItems(
+                      selection.selectionMode as ItemType,
+                      selection.selectedItemsList
+                    );
+                    selection.clearSelection();
+                    selection.setSelectionMode(undefined);
+                  },
+                  visible:
+                    type !== "trash" && type !== "note" && type !== "notebook",
                   icon: "delete"
                 },
                 {

apps/mobile/app/components/sheets/add-notebook/index.tsx

@@ -100,7 +100,6 @@ 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,13 +90,12 @@ 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/change-email/index.tsx

@@ -134,8 +134,10 @@ export const ChangeEmail = ({ close }: ChangeEmailProps) => {
         ) : (
           <>
             <Input
+              key="code-input"
               fwdRef={codeInputRef}
-              placeholder={strings.verifyNewEmail()}
+              placeholder={strings.code()}
+              defaultValue=""
               onChangeText={(code) => {
                 emailChangeData.current.code = code;
               }}

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 { Note } from "@notesnook/core";
-import { EVENTS } from "@notesnook/core";
+import { EVENTS, Note } from "@notesnook/core";
+import { strings } from "@notesnook/intl";
 import { useThemeColors } from "@notesnook/theme";
 import React, { useEffect } from "react";
 import { View } from "react-native";
@@ -25,27 +25,18 @@ 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 { useTabStore } from "../../../screens/editor/tiptap/use-tab-store";
+import {
+  TabItem,
+  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;
@@ -53,7 +44,7 @@ const TabItemComponent = (props: {
   close?: (ctx?: string | undefined) => void;
 }) => {
   const { colors } = useThemeColors();
-  const [item, update] = useDBItem(props.tab.noteId, "note");
+  const [item, update] = useDBItem(props.tab.session?.noteId, "note");
 
   useEffect(() => {
     const syncCompletedSubscription = db.eventManager?.subscribe(
@@ -85,11 +76,11 @@ const TabItemComponent = (props: {
       onPress={() => {
         if (!props.isFocused) {
           useTabStore.getState().focusTab(props.tab.id);
-          if (props.tab.locked) {
+          if (props.tab.session?.locked) {
             eSendEvent(eUnlockNote);
           }
 
-          if (!props.tab.noteId) {
+          if (!props.tab.session?.noteId) {
             setTimeout(() => {
               editorController?.current?.commands?.focus(props.tab.id);
             }, 300);
@@ -97,11 +88,6 @@ const TabItemComponent = (props: {
         }
         props.close?.();
       }}
-      onLongPress={() => {
-        useTabStore.getState().updateTab(props.tab.id, {
-          previewTab: false
-        });
-      }}
     >
       <View
         style={{
@@ -112,9 +98,9 @@ const TabItemComponent = (props: {
           flexShrink: 1
         }}
       >
-        {props.tab.noteLocked ? (
+        {props.tab.session?.noteLocked ? (
           <>
-            {props.tab.locked ? (
+            {props.tab.session?.locked ? (
               <Icon size={SIZE.md} name="lock" />
             ) : (
               <Icon size={SIZE.md} name="lock-open-outline" />
@@ -122,7 +108,9 @@ const TabItemComponent = (props: {
           </>
         ) : null}
 
-        {props.tab.readonly ? <Icon size={SIZE.md} name="pencil-lock" /> : null}
+        {props.tab.session?.readonly ? (
+          <Icon size={SIZE.md} name="pencil-lock" />
+        ) : null}
 
         <Paragraph
           color={
@@ -130,15 +118,10 @@ 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.noteId
+          {props.tab.session?.noteId
             ? item?.title || strings.untitledNote()
             : strings.newNote()}
         </Paragraph>
@@ -157,8 +140,7 @@ const TabItemComponent = (props: {
           color={props.tab.pinned ? colors.primary.accent : colors.primary.icon}
           onPress={() => {
             useTabStore.getState().updateTab(props.tab.id, {
-              pinned: !props.tab.pinned,
-              previewTab: false
+              pinned: !props.tab.pinned
             });
           }}
           top={0}
@@ -197,6 +179,7 @@ export default function EditorTabs({
 }: {
   close?: (ctx?: string | undefined) => void;
 }) {
+  const { colors } = useThemeColors();
   const [tabs, currentTab] = useTabStore((state) => [
     state.tabs,
     state.currentTab
@@ -233,25 +216,13 @@ export default function EditorTabs({
         }}
       >
         <Heading size={SIZE.lg}>{strings.tabs()}</Heading>
-        <Button
+        <IconButton
           onPress={() => {
             useTabStore.getState().newTab();
-            setTimeout(() => {
-              editorController?.current?.commands?.focus(
-                useTabStore.getState().currentTab
-              );
-            }, 500);
             close?.();
           }}
-          title={strings.newTab()}
-          icon="plus"
-          style={{
-            flexDirection: "row",
-            justifyContent: "flex-start",
-            borderRadius: 100,
-            height: 35
-          }}
-          iconSize={SIZE.lg}
+          name="plus"
+          color={colors.primary.accent}
         />
       </View>
 

apps/mobile/app/components/sheets/export-notes/index.tsx

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

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

@@ -62,7 +62,9 @@ export const ShareComponent = ({ uri, name, padding }) => {
             showOpenWithDialog: true,
             showAppsSuggestions: true,
             shareFile: true
-          }).catch(console.log);
+          }).catch(() => {
+            /* empty */
+          });
         }}
       />
     </View>

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

@@ -22,24 +22,22 @@ 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,
@@ -194,7 +192,7 @@ export default function LinkNote(props: {
           }
         : undefined
     );
-    editorController.current?.postMessage(EditorEvents.resolve, {
+    editorController.current?.postMessage(NativeEvents.resolve, {
       data: {
         href: link,
         title: selectedNote.title

apps/mobile/app/components/sheets/manage-tags/index.tsx

@@ -113,11 +113,9 @@ 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/notebook-sheet/index.tsx

@@ -301,8 +301,8 @@ export const NotebookSheet = () => {
                   }}
                   onPress={async () => {
                     await deleteItems(
-                      useItemSelectionStore.getState().getSelectedItemIds(),
-                      "notebook"
+                      "notebook",
+                      useItemSelectionStore.getState().getSelectedItemIds()
                     );
                     useSelectionStore.getState().clearSelection();
                     useItemSelectionStore.setState({

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

@@ -150,7 +150,7 @@ const PublishNoteSheet = ({
         </View>
       ) : (
         <>
-          {isPublished && (
+          {isPublished && publishUrl ? (
             <View
               style={{
                 flexDirection: "row",
@@ -204,7 +204,7 @@ const PublishNoteSheet = ({
                 name="content-copy"
               />
             </View>
-          )}
+          ) : null}
 
           <TouchableOpacity
             onPress={() => {

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

@@ -17,12 +17,17 @@ 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 { sanitizeFilename } from "@notesnook/common";
+import { strings } from "@notesnook/intl";
 import Clipboard from "@react-native-clipboard/clipboard";
 import React, { createRef } from "react";
 import { Platform, View } from "react-native";
+import RNFetchBlob from "react-native-blob-util";
 import FileViewer from "react-native-file-viewer";
 import * as ScopedStorage from "react-native-scoped-storage";
 import Share from "react-native-share";
+import { db } from "../../../common/database";
+import filesystem from "../../../common/filesystem";
 import {
   eSubscribeEvent,
   eUnSubscribeEvent,
@@ -30,8 +35,6 @@ import {
 } from "../../../services/event-manager";
 import { clearMessage } from "../../../services/message";
 import SettingsService from "../../../services/settings";
-import { db } from "../../../common/database";
-import Storage from "../../../common/database/storage";
 import { eOpenRecoveryKeyDialog } from "../../../utils/events";
 import { SIZE } from "../../../utils/size";
 import { sleep } from "../../../utils/time";
@@ -41,9 +44,6 @@ import Seperator from "../../ui/seperator";
 import SheetWrapper from "../../ui/sheet";
 import { QRCode } from "../../ui/svg/lazy";
 import Paragraph from "../../ui/typography/paragraph";
-import RNFetchBlob from "react-native-blob-util";
-import { sanitizeFilename } from "@notesnook/common";
-import { strings } from "@notesnook/intl";
 
 class RecoveryKeySheet extends React.Component {
   constructor(props) {
@@ -126,7 +126,7 @@ class RecoveryKeySheet extends React.Component {
             "base64"
           );
         } else {
-          path = await Storage.checkAndCreateDir("/");
+          path = await filesystem.checkAndCreateDir("/");
           await RNFetchBlob.fs.writeFile(path + fileName, data, "base64");
         }
         ToastManager.show({
@@ -157,7 +157,7 @@ class RecoveryKeySheet extends React.Component {
         if (!file) return;
         path = file.uri;
       } else {
-        path = await Storage.checkAndCreateDir("/");
+        path = await filesystem.checkAndCreateDir("/");
         await RNFetchBlob.fs.writeFile(path + fileName, this.state.key, "utf8");
         path = path + fileName;
       }
@@ -191,13 +191,17 @@ class RecoveryKeySheet extends React.Component {
         Share.open({
           url: path,
           failOnCancel: false
-        }).catch(console.log);
+        }).catch(() => {
+          /* empty */
+        });
       } else {
         FileViewer.open(path, {
           showOpenWithDialog: true,
           showAppsSuggestions: true,
           shareFile: true
-        }).catch(console.log);
+        }).catch(() => {
+          /* empty */
+        });
       }
     } 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,7 +419,6 @@ 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/reminder-notify/index.tsx

@@ -68,19 +68,19 @@ export default function ReminderNotify({
 
   const QuickActions = [
     {
-      title: `5 ${strings.timeShort.minute}`,
+      title: `5 ${strings.timeShort.minute()}`,
       time: 5
     },
     {
-      title: `15 ${strings.timeShort.minute}`,
+      title: `15 ${strings.timeShort.minute()}`,
       time: 15
     },
     {
-      title: `30 ${strings.timeShort.minute}`,
+      title: `30 ${strings.timeShort.minute()}`,
       time: 30
     },
     {
-      title: `1 ${strings.timeShort.hour}`,
+      title: `1 ${strings.timeShort.hour()}`,
       time: 60
     }
   ];

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

@@ -556,9 +556,9 @@ export default function ReminderSheet({
             {Object.keys(ReminderNotificationModes).map((mode) => (
               <Button
                 key={mode}
-                title={strings.reminderNotificationModes[
-                  mode as keyof typeof strings.reminderNotificationModes
-                ]()}
+                title={strings.reminderNotificationModes(
+                  mode as keyof typeof ReminderNotificationModes
+                )}
                 style={{
                   marginRight: 12,
                   borderRadius: 100

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/g, ""));
+  notes = notes?.map((n) => n.replace(/\n|<br>/g, ""));
   const isGithubRelease = Config.GITHUB_RELEASE === "true";
 
   const getSupportedAbi = () => {
@@ -178,18 +178,20 @@ export const Update = ({ version: appVersion, fwdRef }) => {
                 {version.body}
               </Paragraph>
             ) : null}
-            {notes.map((item) => (
-              <Paragraph
-                key={item}
-                color={colors.secondary.paragraph}
-                style={{
-                  marginBottom: 5
-                }}
-                selectable
-              >
-                • {item}
-              </Paragraph>
-            ))}
+            {notes.map((item) =>
+              item && item !== "" ? (
+                <Paragraph
+                  key={item}
+                  color={colors.secondary.paragraph}
+                  style={{
+                    marginBottom: 5
+                  }}
+                  selectable
+                >
+                  • {item}
+                </Paragraph>
+              ) : null
+            )}
           </ScrollView>
           <Seperator />
           <Button
@@ -215,7 +217,9 @@ export const Update = ({ version: appVersion, fwdRef }) => {
               marginTop: 10
             }}
             onPress={() => {
-              Linking.openURL(GITHUB_PAGE_URL).catch(console.log);
+              Linking.openURL(GITHUB_PAGE_URL).catch(() => {
+                /* empty */
+              });
             }}
           >
             {strings.readReleaseNotes()}

apps/mobile/app/components/ui/animated-button/index.tsx

@@ -1,158 +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 React from "react";
-import { ActivityIndicator, DimensionValue, ViewStyle } from "react-native";
-import Animated, {
-  FadeIn,
-  FadeOut,
-  Layout,
-  LightSpeedInLeft
-} from "react-native-reanimated";
-import Icon from "react-native-vector-icons/MaterialCommunityIcons";
-import { SIZE } from "../../../utils/size";
-import NativeTooltip from "../../../utils/tooltip";
-import { ButtonProps } from "../button";
-import { Pressable, useButton } from "../pressable";
-import Heading from "../typography/heading";
-import Paragraph from "../typography/paragraph";
-const AnimatedIcon = Animated.createAnimatedComponent(Icon);
-
-export const AnimatedButton = ({
-  height = 45,
-  width = null,
-  onPress,
-  loading = false,
-  title = null,
-  icon,
-  fontSize = SIZE.sm,
-  type = "transparent",
-  iconSize = SIZE.md,
-  style = {},
-  accentColor = "accent",
-  accentText = "light",
-  onLongPress,
-  tooltipText,
-  textStyle,
-  iconPosition = "left",
-  buttonType,
-  bold,
-  iconColor,
-  fwdRef,
-  ...restProps
-}: ButtonProps) => {
-  const { text } = useButton({
-    type,
-    accent: accentColor,
-    text: accentText
-  });
-  const textColor = buttonType?.text ? buttonType.text : text;
-  const Component = bold ? Heading : Paragraph;
-
-  return (
-    <Animated.View
-      entering={FadeIn}
-      exiting={FadeOut}
-      layout={Layout.springify()}
-    >
-      <Pressable
-        {...restProps}
-        fwdRef={fwdRef}
-        onPress={onPress}
-        onLongPress={(event) => {
-          if (onLongPress) {
-            onLongPress(event);
-            return;
-          }
-          if (tooltipText) {
-            NativeTooltip.show(event, tooltipText, NativeTooltip.POSITIONS.TOP);
-          }
-        }}
-        disabled={loading}
-        type={type}
-        accentColor={accentColor}
-        accentText={accentText}
-        customColor={buttonType?.color}
-        customSelectedColor={buttonType?.selected}
-        customOpacity={buttonType?.opacity}
-        customAlpha={buttonType?.alpha}
-        style={{
-          height: height,
-          width: (width as DimensionValue) || undefined,
-          paddingHorizontal: 12,
-          borderRadius: 5,
-          alignSelf: "center",
-          justifyContent: "center",
-          alignItems: "center",
-          flexDirection: "row",
-          ...(style as ViewStyle)
-        }}
-      >
-        {loading ? (
-          <ActivityIndicator color={textColor} size={fontSize + 4} />
-        ) : null}
-        {icon && !loading && iconPosition === "left" ? (
-          <AnimatedIcon
-            exiting={FadeOut.duration(100)}
-            entering={LightSpeedInLeft}
-            layout={Layout.springify()}
-            name={icon}
-            style={{
-              marginRight: 0
-            }}
-            color={iconColor || buttonType?.text || textColor}
-            size={iconSize}
-          />
-        ) : null}
-
-        {!title ? null : (
-          <Component
-            layout={Layout.springify()}
-            animated={true}
-            color={textColor as string}
-            size={fontSize}
-            numberOfLines={1}
-            style={[
-              {
-                marginLeft:
-                  icon || (loading && iconPosition === "left") ? 5 : 0,
-                marginRight:
-                  icon || (loading && iconPosition === "right") ? 5 : 0
-              },
-              textStyle
-            ]}
-          >
-            {title}
-          </Component>
-        )}
-
-        {icon && !loading && iconPosition === "right" ? (
-          <Icon
-            name={icon}
-            style={{
-              marginLeft: 0
-            }}
-            color={iconColor || buttonType?.text || textColor}
-            size={iconSize}
-          />
-        ) : null}
-      </Pressable>
-    </Animated.View>
-  );
-};

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

@@ -263,20 +263,22 @@ export const Pressable = ({
   const getStyle = useCallback(
     ({ pressed }: PressableStateCallbackType): ViewStyle | ViewStyle[] => [
       {
-        backgroundColor: pressed
-          ? RGB_Linear_Shade(alpha, hexToRGBA(selectedColor, opacity || 1))
-          : hexToRGBA(primaryColor, opacity || 1),
+        backgroundColor:
+          pressed && !disabled
+            ? 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
-          ? customSelectedColor
-            ? getColorLinearShade(customSelectedColor, 0.3, false)
-            : borderSelectedColor || borderColor
-          : borderColor || "transparent",
+        borderColor:
+          pressed && !disabled
+            ? customSelectedColor
+              ? getColorLinearShade(customSelectedColor, 0.3, false)
+              : borderSelectedColor || borderColor
+            : borderColor || "transparent",
         borderWidth: borderWidth
       },
       style,
@@ -298,7 +300,8 @@ export const Pressable = ({
       borderColor,
       borderWidth,
       style,
-      growFactor
+      growFactor,
+      disabled
     ]
   );
 

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

@@ -59,8 +59,9 @@ 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(() => {
@@ -99,24 +100,21 @@ const SheetWrapper = ({
   };
 
   useEffect(() => {
-    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;
-            }
-          });
-        }
+    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;
+          }
+        });
       }
     }
-  }, [appState, fwdRef]);
+  }, [locked, fwdRef]);
 
   return (
     <ScopedThemeProvider value="sheet">

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

@@ -18,15 +18,15 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import React from "react";
-import { View } from "react-native";
+import { DimensionValue, View } from "react-native";
 import { SvgXml } from "./lazy";
 export const SvgView = ({
   width = 250,
   height = 250,
   src
 }: {
-  width?: number | string;
-  height?: number | number;
+  width?: DimensionValue;
+  height?: DimensionValue;
   src?: string;
 }) => {
   if (!src) return null;

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

@@ -315,7 +315,9 @@ const trialstarted: { id: string; steps: TStep[] } = {
       actionButton: {
         text: strings.joinDiscord(),
         action: () => {
-          Linking.openURL("https://discord.gg/zQBK97EE22").catch(console.log);
+          Linking.openURL("https://discord.gg/zQBK97EE22").catch(() => {
+            /* empty */
+          });
         }
       }
     }
@@ -366,7 +368,9 @@ const Support = () => {
           width: "90%"
         }}
         onPress={() => {
-          Linking.openURL("https://discord.gg/zQBK97EE22").catch(console.log);
+          Linking.openURL("https://discord.gg/zQBK97EE22").catch(() => {
+            /* empty */
+          });
         }}
         icon="discord"
         type="secondary"
@@ -380,7 +384,9 @@ const Support = () => {
           width: "90%"
         }}
         onPress={() => {
-          Linking.openURL("https://t.me/notesnook").catch(console.log);
+          Linking.openURL("https://t.me/notesnook").catch(() => {
+            /* empty */
+          });
         }}
         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,
-  createInternalLink
+  VAULT_ERRORS
 } 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
+  presentSheet,
+  ToastManager
 } from "../services/event-manager";
 import Navigation from "../services/navigation";
 import Notifications from "../services/notifications";
@@ -254,8 +254,8 @@ export const useActions = ({
       item.type === "color"
     ) {
       presentDialog({
-        title: strings.doActions.delete[item.type](1),
-        paragraph: strings.actionConfirmations.delete[item.type](1),
+        title: strings.doActions.delete.unknown(item.type, 1),
+        paragraph: strings.actionConfirmations.delete.unknown(item.type, 1),
         positivePress: async () => {
           if (item.type === "reminder") {
             await db.reminders.remove(item.id);
@@ -290,7 +290,7 @@ export const useActions = ({
       });
     } else {
       try {
-        await deleteItems([item.id], item.type);
+        await deleteItems(item.type, [item.id]);
       } catch (e) {
         console.error(e);
       }
@@ -303,8 +303,8 @@ export const useActions = ({
     close();
     await sleep(300);
     presentDialog({
-      title: strings.doActions.delete[item.itemType](1),
-      paragraph: strings.actionConfirmations.delete[item.itemType](1),
+      title: strings.doActions.delete.unknown(item.itemType, 1),
+      paragraph: strings.actionConfirmations.delete.unknown(item.itemType, 1),
       positiveText: strings.delete(),
       negativeText: strings.cancel(),
       positivePress: async () => {
@@ -313,10 +313,7 @@ export const useActions = ({
           Navigation.queueRoutesForUpdate();
           useSelectionStore.getState().setSelectionMode(undefined);
           ToastManager.show({
-            heading:
-              strings.actions.deleted[
-                item.itemType as keyof typeof strings.actions.deleted
-              ](1),
+            heading: strings.actions.deleted.unknown(item.itemType, 1),
             type: "success",
             context: "local"
           });
@@ -547,14 +544,13 @@ export const useActions = ({
     const toggleReadyOnlyMode = async () => {
       const currentReadOnly = (item as Note).readonly;
       await db.notes.readonly(!currentReadOnly, item?.id);
-
-      if (useTabStore.getState().hasTabForNote(item.id)) {
-        const tabId = useTabStore.getState().getTabForNote(item.id);
-        if (!tabId) return;
-        useTabStore.getState().updateTab(tabId, {
-          readonly: !currentReadOnly
+      useTabStore.getState().forEachNoteTab(item.id, (tab) => {
+        useTabStore.getState().updateTab(tab.id, {
+          session: {
+            readonly: !currentReadOnly
+          }
         });
-      }
+      });
       Navigation.queueRoutesForUpdate();
       close();
     };
@@ -957,11 +953,10 @@ export const useActions = ({
     id: "trash",
     title:
       item.type !== "notebook" && item.type !== "note"
-        ? strings.doActions.delete[
-            item.type === "trash"
-              ? item.itemType
-              : (item.type as keyof typeof strings.doActions.delete)
-          ](1)
+        ? strings.doActions.delete.unknown(
+            item.type === "trash" ? item.itemType : item.type,
+            1
+          )
         : strings.moveToTrash(),
     icon: "delete-outline",
     type: "error",

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

@@ -17,9 +17,15 @@ 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 { User } from "@notesnook/core";
-import { EV, EVENTS, SYNC_CHECK_IDS, SyncStatusEvent } from "@notesnook/core";
-import { EventManagerSubscription } from "@notesnook/core";
+import {
+  EV,
+  EVENTS,
+  EventManagerSubscription,
+  SYNC_CHECK_IDS,
+  SyncStatusEvent,
+  User
+} from "@notesnook/core";
+import { strings } from "@notesnook/intl";
 import notifee from "@notifee/react-native";
 import NetInfo, { NetInfoSubscription } from "@react-native-community/netinfo";
 import React, { useCallback, useEffect, useRef } from "react";
@@ -41,10 +47,14 @@ import * as RNIap from "react-native-iap";
 import { DatabaseLogger, db, setupDatabase } from "../common/database";
 import { initializeLogger } from "../common/database/logger";
 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 { Walkthrough } from "../components/walkthroughs";
-import { useTabStore } from "../screens/editor/tiptap/use-tab-store";
+import {
+  resetTabStore,
+  useTabStore
+} from "../screens/editor/tiptap/use-tab-store";
 import {
   clearAppState,
   editorController,
@@ -52,12 +62,14 @@ import {
 } from "../screens/editor/tiptap/utils";
 import { useDragState } from "../screens/settings/editor/state";
 import BackupService from "../services/backup";
+import BiometricService from "../services/biometrics";
 import {
   ToastManager,
   eSendEvent,
   eSubscribeEvent,
   presentSheet
 } from "../services/event-manager";
+import { IntentService } from "../services/intent";
 import {
   clearMessage,
   setEmailVerifyMessage,
@@ -66,14 +78,17 @@ import {
   setRecoveryKeyMessage,
   setUpdateAvailableMessage
 } from "../services/message";
+import Navigation from "../services/navigation";
 import Notifications from "../services/notifications";
 import PremiumService from "../services/premium";
 import SettingsService from "../services/settings";
 import Sync from "../services/sync";
-import { initAfterSync } from "../stores";
+import { clearAllStores, initAfterSync } from "../stores";
+import { refreshAllStores } from "../stores/create-db-collection-store";
 import { useAttachmentStore } from "../stores/use-attachment-store";
 import { useMessageStore } from "../stores/use-message-store";
 import { useSettingStore } from "../stores/use-setting-store";
+import { changeSystemBarColors } from "../stores/use-theme-store";
 import { SyncStatus, useUserStore } from "../stores/use-user-store";
 import { updateStatusBarColor } from "../utils/colors";
 import { BETA } from "../utils/constants";
@@ -89,11 +104,9 @@ import {
 } from "../utils/events";
 import { getGithubVersion } from "../utils/github-version";
 import { tabBarRef } from "../utils/global-refs";
-import { sleep } from "../utils/time";
 import { NotesnookModule } from "../utils/notesnook-module";
-import { changeSystemBarColors } from "../stores/use-theme-store";
-import { strings } from "@notesnook/intl";
-import { endProgress, startProgress } from "../components/dialogs/progress";
+import { sleep } from "../utils/time";
+import ReminderSheet from "../components/sheets/reminder";
 
 const onCheckSyncStatus = async (type: SyncStatusEvent) => {
   const { disableSync, disableAutoSync } = SettingsService.get();
@@ -148,6 +161,8 @@ const onUserSessionExpired = async () => {
 
 const onAppOpenedFromURL = async (event: { url: string }) => {
   const url = event.url;
+
+  console.log("URL", url);
   try {
     if (url.startsWith("https://app.notesnook.com/account/verified")) {
       await onUserEmailVerified();
@@ -157,6 +172,25 @@ 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);
@@ -208,11 +242,20 @@ const onRequestPartialSync = async (
 };
 
 const onLogout = async (reason: string) => {
-  DatabaseLogger.log("User Logged Out" + reason);
-  Notifications.setupReminders(true);
-  SettingsService.set({
-    introCompleted: true
+  DatabaseLogger.log("User Logged Out " + reason);
+  setLoginMessage();
+  await PremiumService.setPremiumStatus();
+  await BiometricService.resetCredentials();
+  MMKV.clearStore();
+  resetTabStore();
+  clearAllStores();
+  setImmediate(() => {
+    refreshAllStores();
   });
+  Navigation.queueRoutesForUpdate();
+  SettingsService.resetSettings();
+  useUserStore.getState().setUser(null);
+  useUserStore.getState().setSyncing(false);
 };
 
 async function checkForShareExtensionLaunchedInBackground() {
@@ -237,9 +280,7 @@ async function checkForShareExtensionLaunchedInBackground() {
       if (note) setTimeout(() => eSendEvent("loadingNote", note), 1);
       MMKV.removeItem("shareExtensionOpened");
     }
-  } catch (e) {
-    console.log(e);
-  }
+  } catch (e) {}
 }
 
 async function saveEditorState() {
@@ -480,12 +521,14 @@ export const useAppEvents = () => {
         }
 
         if (fullBackup) {
-          await BackupService.run(true, undefined, "full");
+          await BackupService.run(false, undefined, "full");
         }
       }
 
       if (SettingsService.getProperty("offlineMode")) {
-        db.attachments.cacheAttachments().catch(console.log);
+        db.attachments.cacheAttachments().catch(() => {
+          /* empty */
+        });
       }
     }
   }, []);
@@ -533,7 +576,6 @@ export const useAppEvents = () => {
           });
         }
       } catch (e) {
-        console.log(e);
         ToastManager.error(e as Error, "Error updating user", "global");
       }
 
@@ -581,7 +623,8 @@ export const useAppEvents = () => {
       EV.subscribe(EVENTS.migrationStarted, (name) => {
         if (
           name !== "notesnook" ||
-          !SettingsService.getProperty("introCompleted")
+          !SettingsService.getProperty("introCompleted") ||
+          Config.isTesting === "true"
         )
           return;
         startProgress({
@@ -594,7 +637,8 @@ export const useAppEvents = () => {
       EV.subscribe(EVENTS.migrationFinished, (name) => {
         if (
           name !== "notesnook" ||
-          !SettingsService.getProperty("introCompleted")
+          !SettingsService.getProperty("introCompleted") ||
+          Config.isTesting === "true"
         )
           return;
         endProgress();
@@ -602,22 +646,17 @@ 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)?.noteId;
+          const noteId = useTabStore.getState().getTab(tab.id)?.session?.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, {
-              locked: true
+              session: {
+                locked: true,
+                noteLocked: true
+              }
             });
-            if (
-              tab.id === useTabStore.getState().currentTab &&
-              locked &&
-              !editorState().movedAway
-            ) {
-              // Show unlock note screen.
-              eSendEvent(eUnlockNote);
-            }
           }
         }
       }),
@@ -626,6 +665,7 @@ export const useAppEvents = () => {
 
     const emitterSubscriptions = [
       Linking.addEventListener("url", onAppOpenedFromURL),
+
       SodiumEventEmitter.addListener(
         "onSodiumProgress",
         onFileEncryptionProgress
@@ -760,9 +800,7 @@ export const useAppEvents = () => {
   useEffect(() => {
     if (!appLocked && isAppLoading) {
       initializeLogger()
-        .catch((e) => {
-          console.log(e);
-        })
+        .catch((e) => {})
         .finally(() => {
           //@ts-ignore
           initializeDatabase();

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

@@ -32,18 +32,11 @@ export function useAppState() {
     const subscription = AppState.addEventListener("change", onChange);
 
     return () => {
-      // @ts-expect-error - React Native >= 0.65
-      if (typeof subscription?.remove === "function") {
-        // @ts-expect-error - need update @types/react-native@0.65.x
-        subscription.remove();
-      } else {
-        // React Native < 0.65
-        AppState.removeEventListener("change", onChange);
-      }
+      subscription.remove();
     };
   }, []);
 
   return appState;
 }
 
-export { AppStateStatus };
+export type { AppStateStatus };

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

@@ -196,7 +196,6 @@ 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-keyboard.ts

@@ -18,7 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { useEffect, useState } from "react";
-import { Keyboard, KeyboardEventListener, ScreenRect } from "react-native";
+import { Keyboard, KeyboardEventListener, KeyboardMetrics } from "react-native";
 
 const emptyCoordinates = Object.freeze({
   screenX: 0,
@@ -34,8 +34,8 @@ const initialValue = {
 export default function useKeyboard() {
   const [shown, setShown] = useState(false);
   const [coordinates, setCoordinates] = useState<{
-    start: undefined | ScreenRect;
-    end: ScreenRect;
+    start: undefined | KeyboardMetrics;
+    end: KeyboardMetrics;
   }>(initialValue);
   const [keyboardHeight, setKeyboardHeight] = useState<number>(0);
 

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

@@ -74,10 +74,8 @@ 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

@@ -45,6 +45,9 @@ import { useSelectionStore } from "../stores/use-selection-store";
 import { useSettingStore } from "../stores/use-setting-store";
 import { rootNavigatorRef } from "../utils/global-refs";
 import { strings } from "@notesnook/intl";
+import { IntentService } from "../services/intent";
+import ReminderSheet from "../components/sheets/reminder";
+import { db } from "../common/database";
 
 const NativeStack = createNativeStackNavigator();
 const IntroStack = createNativeStackNavigator();
@@ -76,12 +79,24 @@ 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(() => {
+    setTimeout(async () => {
       useNavigationStore.getState().update(homepage);
+      const intent = IntentService.getLaunchIntent();
+      if (intent && intent["com.streetwriters.notesnook.OpenReminderId"]) {
+        const reminder = await db.reminders.reminder(
+          intent["com.streetwriters.notesnook.OpenReminderId"]
+        );
+        if (reminder) {
+          ReminderSheet.present(reminder);
+        }
+      } else if (intent["com.streetwriters.notesnook.NewReminder"]) {
+        ReminderSheet.present();
+      }
     }, 1000);
   }, [homepage]);
 

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

@@ -97,7 +97,7 @@ const _TabsHolder = () => {
         tabBarRef.current?.goToPage(1, false);
         return;
       }
-      if (item.type === "notesnook.action.newnote") {
+      if (item && item.type === "notesnook.action.newnote") {
         clearAppState();
         if (!tabBarRef.current) {
           await sleep(3000);
@@ -529,7 +529,9 @@ const onChangeTab = async (event) => {
         const locked = note && (await db.vaults.itemExists(note));
         if (locked) {
           useTabStore.getState().updateTab(tab.id, {
-            locked: true
+            session: {
+              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,14 +36,15 @@
     "@streetwriters/kysely": "^0.27.4",
     "pathe": "1.1.2",
     "react-native-format-currency": "0.0.5",
-    "@lingui/react": "4.11.2",
-    "@lingui/core": "4.11.2",
+    "@lingui/core": "5.1.2",
+    "@lingui/react": "5.1.2",
     "react-native-check-version": "^1.3.0",
     "react-native-material-menu": "^2.0.0",
     "@trpc/client": "^10.45.2",
     "@trpc/react-query": "^10.45.2",
     "@trpc/server": "^10.45.2",
-    "@tanstack/react-query": "^4.36.1"
+    "@tanstack/react-query": "^4.36.1",
+    "async-mutex": "0.5.0"
   },
   "sideEffects": false
 }

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

@@ -19,6 +19,8 @@ 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,
@@ -46,6 +48,7 @@ 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";
@@ -58,9 +61,6 @@ 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,11 +203,13 @@ const useLockedNoteHandler = () => {
 
   useEffect(() => {
     for (const tab of useTabStore.getState().tabs) {
-      const noteId = useTabStore.getState().getTab(tab.id)?.noteId;
+      const noteId = useTabStore.getState().getTab(tab.id)?.session?.noteId;
       if (!noteId) continue;
-      if (tabRef.current && tabRef.current.noteLocked) {
+      if (tabRef.current && tabRef.current.session?.noteLocked) {
         useTabStore.getState().updateTab(tabRef.current.id, {
-          locked: true
+          session: {
+            locked: true
+          }
         });
       }
     }
@@ -221,23 +223,27 @@ const useLockedNoteHandler = () => {
         biometryAvailable: !!biometry,
         biometryEnrolled: !!fingerprint
       });
-      syncTabs();
+      syncTabs("biometry");
     })();
   }, [tab?.id]);
 
   useEffect(() => {
     const unlockWithBiometrics = async () => {
       try {
-        if (!tabRef.current?.noteLocked || !tabRef.current) return;
+        if (!tabRef.current?.session?.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.noteId) {
+        if (
+          credentials &&
+          credentials?.password &&
+          tabRef.current.session?.noteId
+        ) {
           const note = await db.vault.open(
-            tabRef.current.noteId,
+            tabRef.current.session?.noteId,
             credentials?.password
           );
 
@@ -246,7 +252,9 @@ const useLockedNoteHandler = () => {
           });
 
           useTabStore.getState().updateTab(tabRef.current.id, {
-            locked: false
+            session: {
+              locked: false
+            }
           });
         }
       } catch (e) {
@@ -261,7 +269,7 @@ const useLockedNoteHandler = () => {
       password: string;
       biometrics?: boolean;
     }) => {
-      if (!tabRef.current?.noteId || !tabRef.current) return;
+      if (!tabRef.current?.session?.noteId || !tabRef.current) return;
       if (!password || password.trim().length === 0) {
         ToastManager.show({
           heading: strings.passwordNotEntered(),
@@ -271,7 +279,10 @@ const useLockedNoteHandler = () => {
       }
 
       try {
-        const note = await db.vault.open(tabRef.current?.noteId, password);
+        const note = await db.vault.open(
+          tabRef.current?.session?.noteId,
+          password
+        );
         if (enrollBiometrics && note) {
           try {
             const unlocked = await db.vault.unlock(password);
@@ -302,10 +313,11 @@ const useLockedNoteHandler = () => {
           item: note
         });
         useTabStore.getState().updateTab(tabRef.current.id, {
-          locked: false
+          session: {
+            locked: false
+          }
         });
       } catch (e) {
-        console.log(e);
         ToastManager.show({
           heading: strings.passwordIncorrect(),
           type: "error"
@@ -315,7 +327,7 @@ const useLockedNoteHandler = () => {
 
     const unlock = () => {
       if (
-        (tabRef.current?.locked,
+        (tabRef.current?.session?.locked,
         useTabStore.getState().biometryAvailable &&
           useTabStore.getState().biometryEnrolled &&
           !editorState().movedAway)
@@ -324,10 +336,9 @@ const useLockedNoteHandler = () => {
           unlockWithBiometrics();
         }, 150);
       } else {
-        console.log("Biometrics unavailable.", editorState().movedAway);
         if (!editorState().movedAway) {
           setTimeout(() => {
-            if (tabRef.current && tabRef.current?.locked) {
+            if (tabRef.current && tabRef.current?.session?.locked) {
               editorController.current?.commands.focus(tabRef.current?.id);
             }
           }, 100);
@@ -342,13 +353,13 @@ const useLockedNoteHandler = () => {
       }),
       eSubscribeEvent(eUnlockWithPassword, onSubmit)
     ];
-    if (tabRef.current?.locked && tabBarRef.current?.page() === 2) {
+    if (tabRef.current?.session?.locked && tabBarRef.current?.page() === 2) {
       unlock();
     }
     return () => {
       subs.map((s) => s?.unsubscribe());
     };
-  }, [tab?.id, tab?.locked]);
+  }, [tab?.id, tab?.session?.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 { EventTypes } from "./tiptap/editor-events";
+import { EditorEvents } from "@notesnook/editor-mobile/src/utils/editor-events";
 import { Attachment } from "@notesnook/editor";
 import downloadAttachment from "../../common/filesystem/download-attachment";
-import { EditorEvents } from "./tiptap/utils";
+import { NativeEvents } from "@notesnook/editor-mobile/src/utils/native-events";
 import { useThemeColors } from "@notesnook/theme";
 import useGlobalSafeAreaInsets from "../../hooks/use-global-safe-area-insets";
 import { db } from "../../common/database";
@@ -69,12 +69,11 @@ export function ReadonlyEditor(props: {
     const data = event.nativeEvent.data;
     const editorMessage = JSON.parse(data) as EditorMessage<any>;
 
-    if (editorMessage.type === EventTypes.logger) {
+    if (editorMessage.type === EditorEvents.logger) {
       logger.info("[READONLY EDITOR LOG]", editorMessage.value);
     }
 
-    if (editorMessage.type === EventTypes.readonlyEditorLoaded) {
-      console.log("Readonly editor loaded.");
+    if (editorMessage.type === EditorEvents.readonlyEditorLoaded) {
       props.onLoad?.((content: { data: string; id: string }) => {
         setTimeout(() => {
           noteId.current = content.id;
@@ -87,10 +86,9 @@ export function ReadonlyEditor(props: {
           setLoading(false);
         }, 300);
       });
-    } else if (editorMessage.type === EventTypes.getAttachmentData) {
+    } else if (editorMessage.type === EditorEvents.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",
@@ -106,7 +104,7 @@ export function ReadonlyEditor(props: {
           );
           editorRef.current?.postMessage(
             JSON.stringify({
-              type: EditorEvents.attachmentData,
+              type: NativeEvents.attachmentData,
               value: {
                 resolverId: (editorMessage.value as any).resolverId,
                 data
@@ -115,10 +113,9 @@ export function ReadonlyEditor(props: {
           );
         })
         .catch(() => {
-          console.log("Error downloading attachment data");
           editorRef.current?.postMessage(
             JSON.stringify({
-              type: EditorEvents.attachmentData,
+              type: NativeEvents.attachmentData,
               data: {
                 resolverId: (editorMessage.value as any).resolverId,
                 data: undefined

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

@@ -18,9 +18,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Note } from "@notesnook/core";
-import type { Attachment } from "@notesnook/editor";
-import type { ImageAttributes } from "@notesnook/editor";
-import type { LinkAttributes } from "@notesnook/editor";
+import type {
+  Attachment,
+  ImageAttributes,
+  LinkAttributes
+} from "@notesnook/editor";
 import { createRef, RefObject } from "react";
 import { Platform } from "react-native";
 import { EdgeInsets } from "react-native-safe-area-context";
@@ -37,9 +39,6 @@ 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;
 }
 
@@ -75,110 +74,65 @@ class Commands {
     return call(this.ref, fn(job, name)) as Promise<T>;
   }
 
-  focus = async (tabId: number) => {
+  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) => {
     if (!this.ref.current) return;
+
+    const locked = useTabStore.getState().getTab(tabId)?.session?.locked;
     if (Platform.OS === "android") {
       //this.ref.current?.requestFocus();
       setTimeout(async () => {
         if (!this.ref) return;
         textInput.current?.focus();
-
-        const locked = useTabStore.getState().getTab(tabId)?.locked;
-        await this.doAsync(
-          locked
-            ? `editorControllers[${tabId}]?.focusPassInput();`
-            : `editors[${tabId}]?.commands.focus()`,
-          "focus"
-        );
-
+        await this.sendCommand("focus", tabId, locked);
         this.ref?.current?.requestFocus();
       }, 1);
     } else {
       await sleep(400);
-      await this.doAsync(`editors[${tabId}]?.commands.focus()`, "focus");
+      await this.sendCommand("focus", tabId, locked);
     }
   };
 
-  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();
+  blur = async (tabId: string) => this.sendCommand("blur", tabId);
 
-  `,
-      "blur"
-    );
-
-  clearContent = async (tabId: number) => {
+  clearContent = async (tabId: string) => {
     this.previousSettings = null;
-    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"
-    );
+    await this.sendCommand("clearContent", tabId);
   };
 
   setSessionId = async (id: string | null) =>
-    await this.doAsync(`globalThis.sessionId = "${id}";`);
+    await this.sendCommand("setSessionId", id);
 
   setStatus = async (
     date: string | undefined,
     saved: string,
-    tabId: number
+    tabId: string
   ) => {
-    await this.doAsync(
-      `
-      const statusBar = statusBars[${tabId}];
-      typeof statusBar !== "undefined" && statusBar.current.set({date:"${date}",saved:"${saved}"})`,
-      "setStatus"
+    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
     );
   };
 
-  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) => {
-    await this.doAsync(`
-      if (typeof safeAreaController !== "undefined") {
-        safeAreaController.update(${JSON.stringify(insets)}) 
-      }
-    `);
+    this.sendCommand("setInsets", insets);
   };
 
   updateSettings = async (settings?: Partial<Settings>) => {
@@ -187,13 +141,7 @@ if (typeof statusBar !== "undefined") {
       ...this.previousSettings,
       ...settings
     };
-    await this.doAsync(`
-      if (typeof globalThis.settingsController !== "undefined") {
-        globalThis.settingsController.update(${JSON.stringify(
-          this.previousSettings
-        )}) 
-      }
-    `);
+    this.sendCommand("updateSettings", settings);
   };
 
   setSettings = async (settings?: Partial<Settings>) => {
@@ -206,71 +154,31 @@ if (typeof statusBar !== "undefined") {
         return;
       }
     }
-    await this.doAsync(`
-      if (typeof globalThis.settingsController !== "undefined") {
-        globalThis.settingsController.update(${JSON.stringify(settings)}) 
-      }
-    `);
+    this.sendCommand("setSettings", settings);
   };
 
   setTags = async (note: Note | null | undefined) => {
     if (!note) return;
-    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"
-    );
+    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);
+    });
   };
 
-  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"
-    );
+  clearTags = async (tabId: string) => {
+    await this.sendCommand("clearTags", tabId);
   };
 
   insertAttachment = async (attachment: Attachment, tabId: number) => {
-    await this.doAsync(
-      `const editor = editors[${tabId}];
-editor && editor.commands.insertAttachment(${JSON.stringify(attachment)})`
-    );
+    await this.sendCommand("insertAttachment", attachment, tabId);
   };
 
   setAttachmentProgress = async (
     attachmentProgress: Partial<Attachment>,
     tabId: number
   ) => {
-    await this.doAsync(
-      `const editor = editors[${tabId}];
-editor && editor.commands.updateAttachment(${JSON.stringify(
-        attachmentProgress
-      )}, {
-        preventUpdate: true,
-        query: (attachment) => {
-          return attachment.hash === "${attachmentProgress.hash}";
-        }
-      })`
-    );
+    await this.sendCommand("setAttachmentProgress", attachmentProgress, tabId);
   };
 
   insertImage = async (
@@ -279,50 +187,30 @@ editor && editor.commands.updateAttachment(${JSON.stringify(
     },
     tabId: number
   ) => {
-    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
-      })`
-    );
+    await this.sendCommand("insertImage", image, tabId);
   };
 
   handleBack = async () => {
-    return this.doAsync<boolean>(
-      'response = window.dispatchEvent(new Event("handleBackPress",{cancelable:true}));'
-    );
+    return this.sendCommand("handleBack");
   };
 
   keyboardShown = async (keyboardShown: boolean) => {
-    return this.doAsync(`globalThis['keyboardShown']=${keyboardShown};`);
+    return this.sendCommand("keyboardShown", keyboardShown);
   };
 
   getTableOfContents = async () => {
     const tabId = useTabStore.getState().currentTab;
-    return this.doAsync(`
-      response = editorControllers[${tabId}]?.getTableOfContents() || [];
-    `);
+    return this.sendCommand("getTableOfContents", tabId);
   };
 
   focusPassInput = async () => {
     const tabId = useTabStore.getState().currentTab;
-    return this.doAsync(`
-      response = editorControllers[${tabId}]?.focusPassInput() || [];
-    `);
+    return this.sendCommand("focusPassInput", tabId);
   };
 
   blurPassInput = async () => {
     const tabId = useTabStore.getState().currentTab;
-    return this.doAsync(`
-      response = editorControllers[${tabId}]?.blurPassInput() || [];
-    `);
+    return this.sendCommand("blurPassInput", tabId);
   };
 
   createInternalLink = async (
@@ -330,30 +218,18 @@ editor && editor.commands.insertImage({
     resolverId: string
   ) => {
     if (!resolverId) return;
-    return this.doAsync(`
-    if (globalThis.pendingResolvers["${resolverId}"]) {
-      globalThis.pendingResolvers["${resolverId}"](${JSON.stringify(
-      attributes
-    )});
-    }`);
+    return this.sendCommand("createInternalLink", attributes, resolverId);
   };
 
   dismissCreateInternalLinkRequest = async (resolverId: string) => {
     if (!resolverId) return;
-    return this.doAsync(`
-    if (globalThis.pendingResolvers["${resolverId}"]) {
-      globalThis.pendingResolvers["${resolverId}"](undefined);
-    }
-    `);
+    return this.sendCommand("dismissCreateInternalLinkRequest", resolverId);
   };
 
   scrollIntoViewById = async (id: string) => {
     const tabId = useTabStore.getState().currentTab;
-    return this.doAsync(`
-      response = editorControllers[${tabId}]?.scrollIntoView("${id}") || [];
-    `);
+    return this.sendCommand("scrollIntoViewById", id, tabId);
   };
-  //todo add replace image function
 }
 
 export default Commands;

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

@@ -43,6 +43,7 @@ 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({
@@ -131,7 +132,6 @@ const file = async (fileOptions: PickerOptions) => {
 
     if (
       fileOptions.tabId !== undefined &&
-      fileOptions.noteId &&
       useTabStore.getState().getNoteIdForTab(fileOptions.tabId) ===
         fileOptions.noteId
     ) {
@@ -194,9 +194,7 @@ const camera = async (options: PickerOptions) => {
           options
         );
       })
-      .catch((e) => {
-        console.log("camera error: ", e);
-      });
+      .catch((e) => {});
   } catch (e) {
     ToastManager.show({
       heading: (e as Error).message,
@@ -224,9 +222,7 @@ const gallery = async (options: PickerOptions) => {
           options
         )
       )
-      .catch((e) => {
-        console.log("gallery error: ", e);
-      });
+      .catch((e) => {});
   } catch (e) {
     useSettingStore.getState().setAppDidEnterBackgroundForAction(false);
     ToastManager.show({
@@ -234,13 +230,19 @@ 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;
     }
@@ -251,6 +253,7 @@ 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);
@@ -267,6 +270,7 @@ const handleImageResponse = async (
   options: PickerOptions
 ) => {
   const result = await AttachImage.present(response, options.context);
+
   if (!result) return;
   const compress = result.compress;
 
@@ -310,18 +314,14 @@ 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,7 +388,6 @@ 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);
@@ -397,6 +396,7 @@ 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: number;
+  tabId: string;
   resolverId?: string;
   hasTimeout?: boolean;
 };
@@ -86,7 +86,7 @@ export type SavePayload = {
   type?: "tiptap";
   sessionHistoryId?: number;
   ignoreEdit: boolean;
-  tabId: number;
+  tabId: string;
   pendingChanges?: boolean;
 };
 
@@ -94,4 +94,5 @@ export type AppState = {
   editing: boolean;
   movedAway: boolean;
   timestamp: number;
+  noteId?: string;
 };

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

@@ -21,7 +21,10 @@ 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 {
@@ -72,11 +75,9 @@ 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 { EditorEvents, editorState, openInternalLink } from "./utils";
-import { strings } from "@notesnook/intl";
+import { editorState, openInternalLink } from "./utils";
 
 const publishNote = async () => {
   const user = useUserStore.getState().user;
@@ -101,7 +102,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);
@@ -124,7 +125,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) {
@@ -177,7 +178,7 @@ export const useEditorEvents = (
   useEffect(() => {
     const handleKeyboardDidShow: KeyboardEventListener = () => {
       editor.commands.keyboardShown(true);
-      editor.postMessage(EditorEvents.keyboardShown, undefined);
+      editor.postMessage(NativeEvents.keyboardShown, undefined);
     };
     const handleKeyboardDidHide: KeyboardEventListener = () => {
       editor.commands.keyboardShown(false);
@@ -247,7 +248,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) {
@@ -268,7 +269,6 @@ 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(EditorEvents.resolve, {
+        editor.postMessage(NativeEvents.resolve, {
           data: true,
           resolverId: editorMessage.resolverId
         });
       }
 
-      if (editorMessage.type === EventTypes.load) {
+      if (editorMessage.type === EditorEvents.load) {
         DatabaseLogger.log("Editor is ready");
         editor.onLoad();
         return;
       }
 
-      if (editorMessage.type === EventTypes.back) {
+      if (editorMessage.type === EditorEvents.back) {
         return onBackPress();
       }
 
       if (
         editorMessage.sessionId !== editor.sessionId.current &&
-        editorMessage.type !== EditorEvents.status
+        editorMessage.type !== NativeEvents.status
       ) {
         return;
       }
@@ -381,8 +381,8 @@ export const useEditorEvents = (
         .getNoteIdForTab(editorMessage.tabId);
 
       switch (editorMessage.type) {
-        case EventTypes.content:
-          DatabaseLogger.log("EventTypes.content");
+        case EditorEvents.content:
+          DatabaseLogger.log("EditorEvents.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 EventTypes.title:
-          DatabaseLogger.log("EventTypes.title");
+        case EditorEvents.title:
+          DatabaseLogger.log("EditorEvents.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 EventTypes.logger:
+        case EditorEvents.logger:
           logger.info("[EDITOR LOG]", editorMessage.value);
           break;
-        case EventTypes.dbLogger:
+        case EditorEvents.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 EventTypes.contentchange:
+        case EditorEvents.contentchange:
           editor.onContentChanged(editorMessage.noteId);
           break;
-        case EventTypes.selection:
+        case EditorEvents.selection:
           break;
-        case EventTypes.reminders:
+        case EditorEvents.reminders:
           if (!noteId) {
             ToastManager.show({
               heading: strings.createNoteFirst(),
@@ -442,7 +442,7 @@ export const useEditorEvents = (
             onAdd: () => ReminderSheet.present(undefined, note, true)
           });
           break;
-        case EventTypes.newtag:
+        case EditorEvents.newtag:
           if (!noteId) {
             ToastManager.show({
               heading: strings.createNoteFirst(),
@@ -452,7 +452,7 @@ export const useEditorEvents = (
           }
           ManageTagsSheet.present([noteId]);
           break;
-        case EventTypes.tag:
+        case EditorEvents.tag:
           if (editorMessage.value) {
             if (!noteId) return;
             const note = await db.notes.note(noteId);
@@ -468,7 +468,7 @@ export const useEditorEvents = (
               });
           }
           break;
-        case EventTypes.filepicker:
+        case EditorEvents.filepicker:
           editorState().isAwaitingResult = true;
           const { pick } = require("./picker").default;
           pick({
@@ -480,14 +480,14 @@ export const useEditorEvents = (
             editorState().isAwaitingResult = false;
           }, 1000);
           break;
-        case EventTypes.download: {
+        case EditorEvents.download: {
           const downloadAttachment =
             require("../../../common/filesystem/download-attachment").default;
           downloadAttachment((editorMessage.value as Attachment)?.hash, true);
           break;
         }
 
-        case EventTypes.getAttachmentData: {
+        case EditorEvents.getAttachmentData: {
           const attachment = (editorMessage.value as any)
             ?.attachment as Attachment;
 
@@ -507,14 +507,14 @@ export const useEditorEvents = (
                 !!data,
                 editorMessage.resolverId
               );
-              editor.postMessage(EditorEvents.resolve, {
+              editor.postMessage(NativeEvents.resolve, {
                 resolverId: editorMessage.resolverId,
                 data
               });
             })
             .catch((e) => {
               DatabaseLogger.error(e);
-              editor.postMessage(EditorEvents.resolve, {
+              editor.postMessage(NativeEvents.resolve, {
                 resolverId: editorMessage.resolverId,
                 data: undefined
               });
@@ -523,26 +523,26 @@ export const useEditorEvents = (
           break;
         }
 
-        case EventTypes.pro:
+        case EditorEvents.pro:
           if (editor.state.current?.isFocused) {
             editor.state.current.isFocused = true;
           }
           eSendEvent(eOpenPremiumDialog);
           break;
-        case EventTypes.monograph:
+        case EditorEvents.monograph:
           publishNote();
           break;
-        case EventTypes.properties:
+        case EditorEvents.properties:
           showActionsheet();
           break;
-        case EventTypes.scroll:
+        case EditorEvents.scroll:
           editorState().scrollPosition = editorMessage.value;
           break;
-        case EventTypes.fullscreen:
+        case EditorEvents.fullscreen:
           editorState().isFullscreen = true;
           eSendEvent(eOpenFullscreenEditor);
           break;
-        case EventTypes.link:
+        case EditorEvents.link:
           if (editorMessage.value.startsWith("nn://")) {
             openInternalLink(editorMessage.value);
             console.log(
@@ -554,7 +554,7 @@ export const useEditorEvents = (
           }
           break;
 
-        case EventTypes.previewAttachment: {
+        case EditorEvents.previewAttachment: {
           const hash = (editorMessage.value as Attachment)?.hash;
           const attachment = await db.attachments?.attachment(hash);
           if (!attachment) return;
@@ -565,26 +565,41 @@ export const useEditorEvents = (
           }
           break;
         }
-        case EventTypes.copyToClipboard: {
+        case EditorEvents.copyToClipboard: {
           Clipboard.setString(editorMessage.value as string);
           break;
         }
-        case EventTypes.tabsChanged: {
+        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: {
           // useTabStore.setState({
           //   tabs: (editorMessage.value as any)?.tabs,
           //   currentTab: (editorMessage.value as any)?.currentTab
           // });
-          // console.log("Tabs updated");
+          //
           break;
         }
-        case EventTypes.toc:
+        case EditorEvents.toc:
           TableOfContents.present(editorMessage.value);
           break;
-        case EventTypes.showTabs: {
+        case EditorEvents.showTabs: {
           EditorTabs.present();
           break;
         }
-        case EventTypes.error: {
+        case EditorEvents.error: {
           presentSheet({
             component: (
               <Issue
@@ -596,27 +611,15 @@ export const useEditorEvents = (
           });
           break;
         }
-        case EventTypes.tabFocused: {
-          console.log(
-            "Focused tab",
-            editorMessage.tabId,
-            editorMessage.noteId,
-            "Content:",
-            editorMessage.value
-          );
-
+        case EditorEvents.tabFocused: {
           eSendEvent(eEditorTabFocused, editorMessage.tabId);
 
-          if (
-            (!editorMessage.value || editor.currentLoadingNoteId.current) &&
-            editorMessage.noteId
-          ) {
+          if (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
                 });
               }
@@ -628,7 +631,6 @@ export const useEditorEvents = (
                   if (note) {
                     eSendEvent(eOnLoadNote, {
                       item: note,
-                      forced: true,
                       tabId: editorMessage.tabId
                     });
                   }
@@ -639,7 +641,7 @@ export const useEditorEvents = (
 
           break;
         }
-        case EventTypes.createInternalLink: {
+        case EditorEvents.createInternalLink: {
           LinkNote.present(
             editorMessage.value.attributes,
             editorMessage.resolverId as string
@@ -647,25 +649,37 @@ export const useEditorEvents = (
           break;
         }
 
-        case EventTypes.unlock: {
+        case EditorEvents.unlock: {
           eSendEvent(eUnlockWithPassword, editorMessage.value);
           break;
         }
 
-        case EventTypes.unlockWithBiometrics: {
+        case EditorEvents.goBack: {
+          useTabStore.getState().goBack();
+          break;
+        }
+
+        case EditorEvents.goForward: {
+          useTabStore.getState().goForward();
+          break;
+        }
+
+        case EditorEvents.unlockWithBiometrics: {
           eSendEvent(eUnlockWithBiometrics);
           break;
         }
 
-        case EventTypes.disableReadonlyMode: {
+        case EditorEvents.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, {
-                readonly: false
+              .updateTab(useTabStore.getState().currentTab!, {
+                session: {
+                  readonly: false
+                }
               });
             setTimeout(() => {
               Navigation.queueRoutesForUpdate();

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

@@ -32,8 +32,11 @@ 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";
@@ -46,6 +49,7 @@ 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";
@@ -62,12 +66,10 @@ 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 { syncTabs, useTabStore } from "./use-tab-store";
+import { TabSessionItem, syncTabs, useTabStore } from "./use-tab-store";
 import {
-  EditorEvents,
   clearAppState,
   defaultState,
   getAppState,
@@ -76,10 +78,68 @@ import {
   post
 } from "./utils";
 
+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
+    ) {
+      console.log("tab is refreshing...");
+      return true;
+    }
+    console.log(
+      "Tab refreshing...",
+      state.editedAt < this.noteEditedTime[noteId]
+    );
+
+    console.log(state.editedAt, this.noteEditedTime[noteId]);
+
+    return !state.editedAt || state.editedAt < this.noteEditedTime[noteId];
+  }
+}
+
 export const useEditor = (
   editorId = "",
   readonly?: boolean,
@@ -98,7 +158,6 @@ export const useEditor = (
             isPreview?: boolean;
           };
         })
-      | null
       | undefined
     >
   >({});
@@ -118,15 +177,17 @@ export const useEditor = (
   const lastContentChangeTime = useRef<Record<string, number>>({});
   const lock = useRef(false);
   const currentLoadingNoteId = useRef<string>();
-  const loadingState = useRef<string>();
-  const lastTabFocused = useRef(0);
+  const lastTabFocused = useRef<string>();
+
+  const localTabState = useRef<LocalTabState>(new LocalTabState());
+
   const blockIdRef = useRef<string>();
   const postMessage = useCallback(
-    async <T>(type: string, data: T, tabId?: number, waitFor = 300) =>
+    async <T>(type: string, data: T, tabId?: string, waitFor = 300) =>
       await post(
         editorRef,
         sessionIdRef.current,
-        typeof tabId !== "number" ? useTabStore.getState().currentTab : tabId,
+        tabId || useTabStore.getState().currentTab!,
         type,
         data,
         waitFor
@@ -141,7 +202,7 @@ export const useEditor = (
   }, [commands, insets, isDefaultEditor]);
 
   useEffect(() => {
-    postMessage(EditorEvents.theme, theme);
+    postMessage(NativeEvents.theme, theme);
   }, [theme, postMessage]);
 
   useEffect(() => {
@@ -151,15 +212,14 @@ export const useEditor = (
   }, [commands, tags]);
 
   useEffect(() => {
-    const event = eSubscribeEvent(eEditorTabFocused, (tabId) => {
-      console.log("Editot tab focus changed", lastTabFocused.current, tabId);
+    const event = eSubscribeEvent(eEditorTabFocused, (tabId: string) => {
       if (lastTabFocused.current !== tabId) lock.current = false;
-      lastTabFocused.current = tabId as number;
+      lastTabFocused.current = tabId;
     });
     return () => {
       event?.unsubscribe();
     };
-  });
+  }, []);
 
   const overlay = useCallback(
     (show: boolean, data = { type: "new" }) => {
@@ -188,12 +248,11 @@ export const useEditor = (
   );
 
   const reset = useCallback(
-    async (tabId: number, resetState = true, resetContent = true) => {
-      console.log("Resetting tab:", tabId);
+    async (tabId: string, resetState = true, resetContent = true) => {
       const noteId = useTabStore.getState().getNoteIdForTab(tabId);
       if (noteId) {
         currentNotes.current?.id && db.fs().cancel(noteId);
-        currentNotes.current[noteId] = null;
+        currentNotes.current[noteId] = undefined;
         currentContents.current[noteId] = null;
         editorSessionHistory.clearSession(noteId);
         lastContentChangeTime.current[noteId] = 0;
@@ -201,18 +260,11 @@ export const useEditor = (
       }
 
       saveCount.current = 0;
-      loadingState.current = undefined;
+      currentLoadingNoteId.current = undefined;
       lock.current = false;
-      resetContent && postMessage(EditorEvents.title, "", tabId);
-
+      resetContent && postMessage(NativeEvents.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]
   );
@@ -232,6 +284,16 @@ 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;
@@ -270,13 +332,6 @@ 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;
@@ -311,7 +366,9 @@ export const useEditor = (
             }
 
             useTabStore.getState().updateTab(tabId, {
-              noteId: id
+              session: {
+                noteId: id
+              }
             });
 
             const defaultNotebook = db.settings.getDefaultNotebook();
@@ -326,7 +383,7 @@ export const useEditor = (
 
             if (!noteData.title) {
               postMessage(
-                EditorEvents.title,
+                NativeEvents.title,
                 currentNotes.current[id]?.title,
                 tabId
               );
@@ -386,12 +443,19 @@ export const useEditor = (
           id === useTabStore.getState().getCurrentNoteId() &&
           pendingChanges
         ) {
-          postMessage(EditorEvents.title, title || note?.title, tabId);
-          postMessage(EditorEvents.html, data, tabId);
+          postMessage(NativeEvents.title, title || note?.title, tabId);
+          postMessage(NativeEvents.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);
@@ -429,183 +493,211 @@ export const useEditor = (
   );
 
   const loadNote = useCallback(
-    async (event: {
+    (event: {
       item?: Note;
-      forced?: boolean;
       newNote?: boolean;
-      tabId?: number;
+      tabId?: string;
       blockId?: string;
-      presistTab?: boolean;
+      session?: TabSessionItem;
+      newTab?: boolean;
     }) => {
-      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;
+      loadNoteMutex.runExclusive(async () => {
+        if (!event) return;
+        if (event.blockId) {
+          blockIdRef.current = event.blockId;
         }
-        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 (
-          currentNotes.current[item.id] &&
-          loadingState.current &&
-          currentContents.current[item.id]?.data &&
-          loadingState.current === currentContents.current[item.id]?.data
+          !state.current.ready &&
+          (await isEditorLoaded(
+            editorRef,
+            sessionIdRef.current,
+            useTabStore.getState().currentTab!
+          ))
         ) {
-          // If note is already loading, return.
-          console.log("Note is already loading...");
-          return;
+          state.current.ready = true;
         }
+        if (event.newNote && !currentLoadingNoteId.current) {
+          let tabId;
+          if (useTabStore.getState().tabs.length === 0) {
+            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!, {});
+            }
+          }
 
-        if (!state.current.ready) {
+          setTimeout(() => {
+            if (state.current?.ready && !state.current.movedAway)
+              commands.focus(tabId!);
+          });
+        } else {
+          if (!event.item) {
+            overlay(false);
+            return;
+          }
+
+          const item = event.item;
+
+          // 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);
+
+            const currentTab = useTabStore
+              .getState()
+              .getTab(useTabStore.getState().currentTab as string);
+
+            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;
+
+          console.log(tabId === useTabStore.getState().currentTab);
+
+          // Check if tab needs to be refreshed.
+          if (!event.newTab) {
+            if (
+              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) {
+            useTabStore.getState().newTab({
+              session: session
+            });
+          } else {
+            // A new session is created if the note is changed.
+            // If the note is already opened, the session is updated.
+            if (
+              !tab?.session ||
+              (event.item.id !== tab?.session?.noteId && tab?.session?.noteId)
+            ) {
+              useTabStore.getState().newTabSession(tabId!, session);
+            } else {
+              useTabStore.getState().updateTab(tabId!, {
+                session: session
+              });
+            }
+          }
+
+          if (lastTabFocused.current !== tabId) return;
+
+          if (tabBarRef.current?.page() === 2) {
+            state.current.movedAway = false;
+          }
+
+          state.current.currentlyEditing = true;
+          if (!tabLocked) {
+            await loadContent(item);
+          } else {
+            commands.focus(tabId!);
+          }
+
+          lastContentChangeTime.current[item.id] = item.dateEdited;
           currentNotes.current[item.id] = item;
-          return;
+
+          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);
         }
-
-        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);
+        postMessage(NativeEvents.theme, theme);
+      });
     },
     [
       commands,
@@ -613,7 +705,6 @@ export const useEditor = (
       loadContent,
       overlay,
       postMessage,
-      readonly,
       reset,
       theme
     ]
@@ -625,84 +716,90 @@ export const useEditor = (
       isLocal?: boolean
     ) => {
       try {
-        await (async () => {
-          if (SettingsService.get().disableRealtimeSync && !isLocal) return;
-          if (!data) return;
+        if (SettingsService.get().disableRealtimeSync && !isLocal) return;
+        if (!data) return;
 
-          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;
+        if (isDeleted(data) || isTrashItem(data)) {
+          const tabId = useTabStore.getState().getTabForNote(data.id);
+          if (tabId !== undefined) {
+            await commands.clearContent(tabId);
+            useTabStore.getState().removeTab(tabId);
           }
+          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;
 
-          if (!useTabStore.getState().hasTabForNote(noteId)) return;
-          const tabId = useTabStore.getState().getTabForNote(noteId) as number;
+        const note = data.type === "note" ? data : await db.notes?.note(noteId);
 
-          const tab = useTabStore.getState().getTab(tabId);
+        lock.current = true;
 
-          const note =
-            data.type === "note" ? data : await db.notes?.note(noteId);
+        // Handle this case where note was locked on another device and synced.
+        const locked = note
+          ? await db.vaults.itemExists(note as ItemReference)
+          : false;
 
-          lock.current = true;
-
-          // Handle this case where note was locked on another device and synced.
-          const locked = note
-            ? await db.vaults.itemExists(note as ItemReference)
-            : false;
+        useTabStore.getState().forEachNoteTab(noteId, async (tab) => {
+          const tabId = tab.id;
 
           if (note) {
-            if (!locked && tab?.noteLocked) {
+            if (!locked && tab?.session?.noteLocked) {
               // Note lock removed.
-              if (tab.locked) {
+              if (tab.session?.locked) {
                 if (useTabStore.getState().currentTab === tabId) {
                   eSendEvent(eOnLoadNote, {
-                    item: note,
-                    forced: true
+                    item: note
                   });
                 } else {
                   useTabStore.getState().updateTab(tabId, {
-                    locked: false,
-                    noteLocked: false
+                    session: {
+                      locked: false,
+                      noteLocked: false
+                    }
+                  });
+                  localTabState.current?.set(tabId, {
+                    editedAt: 0
                   });
-                  commands.setLoading(true, tabId);
                 }
               }
-            } else if (!tab?.noteLocked && locked) {
+            } else if (!tab?.session?.noteLocked && locked) {
               // Note lock added.
               useTabStore.getState().updateTab(tabId, {
-                locked: true,
-                noteLocked: true
+                session: {
+                  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) {
-              postMessage(EditorEvents.title, note.title, tabId);
+              postMessage(NativeEvents.title, note.title, tabId);
             }
             commands.setTags(note);
             if (currentNotes.current[noteId]?.dateEdited !== note.dateEdited) {
               commands.setStatus(
                 getFormattedDate(note.dateEdited, "date-time"),
                 strings.saved(),
-                tabId as number
+                tabId as string
               );
             }
-
-            useTabStore.getState().updateTab(tabId, {
-              readonly: note.readonly
-            });
+            if (tab.session?.readonly !== note.readonly) {
+              useTabStore.getState().updateTab(tabId, {
+                session: {
+                  readonly: note.readonly
+                }
+              });
+            }
           }
 
           if (data.type === "tiptap" && note && !isLocal) {
@@ -713,9 +810,11 @@ export const useEditor = (
             if (locked && isEncryptedContent(data)) {
               const decryptedContent = await db.vault?.decryptContent(data);
               if (!decryptedContent) {
-                useTabStore.getState().updateTab(tabId, {
-                  locked: true,
-                  noteLocked: true
+                useTabStore.getState().updateTab(tab.id, {
+                  session: {
+                    locked: true,
+                    noteLocked: true
+                  }
                 });
                 if (useTabStore.getState().currentTab !== tabId) {
                   commands.clearContent(tabId);
@@ -723,7 +822,7 @@ export const useEditor = (
                 }
               } else {
                 await postMessage(
-                  EditorEvents.updatehtml,
+                  NativeEvents.updatehtml,
                   decryptedContent.data,
                   tabId
                 );
@@ -735,14 +834,14 @@ export const useEditor = (
                 return;
               }
               lastContentChangeTime.current[note.id] = note.dateEdited;
-              await postMessage(EditorEvents.updatehtml, _nextContent, tabId);
+              await postMessage(NativeEvents.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 {
@@ -778,7 +877,7 @@ export const useEditor = (
       content?: string;
       type: string;
       ignoreEdit: boolean;
-      tabId: number;
+      tabId: string;
       pendingChanges?: boolean;
     }) => {
       DatabaseLogger.log(
@@ -807,9 +906,13 @@ 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 === EventTypes.content && noteId) {
+      if (type === EditorEvents.content && noteId) {
         currentContents.current[noteId as string] = {
           data: content,
           type: "tiptap",
@@ -859,7 +962,9 @@ export const useEditor = (
     if (!appState) return;
     state.current.isRestoringState = true;
     state.current.currentlyEditing = true;
-    state.current.movedAway = false;
+    if (tabBarRef.current?.page() === 2) {
+      state.current.movedAway = false;
+    }
 
     if (!state.current.editorStateRestored) {
       state.current.isRestoringState = true;
@@ -890,9 +995,12 @@ 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 {
@@ -904,35 +1012,49 @@ export const useEditor = (
 
   const onLoad = useCallback(async () => {
     setTimeout(() => {
-      postMessage(EditorEvents.theme, theme);
+      postMessage(NativeEvents.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;
     }
 
-    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];
+    const appState = getAppState();
+    if (appState?.noteId) {
+      const note = await db.notes?.note(appState.noteId);
       if (note) {
         loadNote({
           item: note
         });
       }
+    } else {
+      const noteId = useTabStore.getState().getCurrentNoteId();
+      if (!noteId) {
+        loadNote({ newNote: true });
+        if (tabBarRef.current?.page() === 1) {
+          state.current.currentlyEditing = false;
+        }
+      } else if (state.current?.initialLoadCalled) {
+        const note = currentNotes.current[noteId];
+        if (note) {
+          loadNote({
+            item: note
+          });
+        }
+      }
+      if (!state.current?.initialLoadCalled) {
+        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,18 +16,27 @@ 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 History {
-  history: number[];
+class TabHistory {
+  history: string[];
   constructor() {
-    this.history = [0];
+    this.history = [];
   }
 
-  add(item: number) {
+  add(item: string) {
     const index = this.history.findIndex((id) => item === id);
     if (index !== -1) {
       // Item already exists, move it to the top
@@ -36,19 +45,19 @@ class History {
     this.history.unshift(item); // Add item to the beginning of the array
 
     useTabStore.setState({
-      tabHistory: this.history.slice()
+      historyNew: this.history.slice()
     });
     return true; // Item added successfully
   }
 
-  remove(id: number) {
+  remove(id: string) {
     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({
-      tabHistory: this.history.slice()
+      historyNew: this.history.slice()
     });
     return null; // Invalid index
   }
@@ -59,7 +68,7 @@ class History {
       return restoredItem;
     }
     useTabStore.setState({
-      tabHistory: this.history.slice()
+      historyNew: this.history.slice()
     });
     return null; // History is empty
   }
@@ -69,149 +78,355 @@ class History {
   }
 }
 
-export type TabItem = {
-  id: number;
+export type TabSessionItem = {
+  id: string;
   noteId?: string;
-  previewTab?: boolean;
-  readonly?: boolean;
-  locked?: boolean;
+  scrollTop?: number;
+  selection?: { to: number; from: number };
   noteLocked?: boolean;
-  pinned?: boolean;
+  locked?: boolean;
+  readonly?: boolean;
 };
 
-const history = new History();
+const TabSessionStorageKV = new MMKVLoader()
+  .withInstanceID("tab-session-storage")
+  .disableIndexing()
+  .initialize();
+
+class TabSessionStorage {
+  static storage: typeof TabSessionStorageKV = TabSessionStorageKV;
+
+  static get(id: string): TabSessionItem | null {
+    return TabSessionStorage.storage.getMap(id);
+  }
+
+  static set(id: string, session: TabSessionItem): void {
+    TabSessionStorage.storage.setMap(id, session);
+  }
+
+  static update(id: string, session: Partial<TabSessionItem>) {
+    const currentSession = TabSessionStorage.get(id);
+    const newSession = {
+      ...currentSession,
+      ...session
+    };
+    TabSessionStorage.set(id, newSession as TabSessionItem);
+    return newSession;
+  }
+
+  static remove(id: string) {
+    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;
+  pinned?: boolean;
+  needsRefresh?: boolean;
+  session?: Partial<TabSessionItem>;
+};
+
+const history = new TabHistory();
 
 export type TabStore = {
   tabs: TabItem[];
-  currentTab: number;
-  updateTab: (id: number, options: Omit<Partial<TabItem>, "id">) => void;
+  currentTab?: string;
+  updateTab: (id: string, options: Omit<Partial<TabItem>, "id">) => void;
   focusPreviewTab: (
     noteId: string,
     options: Omit<Partial<TabItem>, "id">
   ) => void;
-  removeTab: (index: number) => void;
+  removeTab: (index: string) => void;
   moveTab: (index: number, toIndex: number) => void;
-  newTab: (options?: Omit<Partial<TabItem>, "id">) => void;
-  focusTab: (id: number) => void;
-  getNoteIdForTab: (id: number) => string | undefined;
-  getTabForNote: (noteId: string) => number | undefined;
+  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;
   hasTabForNote: (noteId: string) => boolean;
   focusEmptyTab: () => void;
   getCurrentNoteId: () => string | undefined;
-  getTab: (tabId: number) => TabItem | undefined;
-  tabHistory: number[];
+  getTab: (tabId: string) => TabItem | undefined;
+  newTabSession: (
+    id: string,
+    options?: Omit<Partial<TabSessionItem>, "id">
+  ) => void;
+  historyNew: string[];
   biometryAvailable?: boolean;
   biometryEnrolled?: boolean;
+  tabSessionHistory: TabHistoryType;
+  goBack(): void;
+  goForward(): void;
+  loadSession: (id: string) => Promise<boolean>;
+  canGoBack?: boolean;
+  canGoForward?: boolean;
+  sessionId?: string;
 };
 
-function getId(id: number, tabs: TabItem[]): number {
-  const exists = tabs.find((t) => t.id === id);
-  if (exists) {
-    return getId(id + 1, tabs);
-  }
-  return id;
-}
+const DEFAULT_TABS = {
+  tabs: [
+    {
+      id: "679da59a3924d4bd56d16d3f",
+      session: {
+        id: "679da5a5667a16db2353a062"
+      }
+    }
+  ],
+  tabSessionHistory: {
+    "679da59a3924d4bd56d16d3f": {
+      backStack: ["679da5a5667a16db2353a062"],
+      forwardStack: [] as string[]
+    }
+  } as TabHistoryType,
+  historyNew: ["679da59a3924d4bd56d16d3f"],
+  currentTab: "679da59a3924d4bd56d16d3f"
+} as TabStore;
 
-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 function resetTabStore() {
+  useTabStore.setState({
+    ...DEFAULT_TABS
+  });
+  TabSessionStorage.storage.clearStore();
 }
 
 export const useTabStore = create<TabStore>(
   persist(
     (set, get) => ({
-      tabs: [
-        {
-          id: 0
+      ...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;
+            }
+          });
         }
-      ],
-      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);
+
+        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 = {
+            ...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],
-          ...options
-        };
+          session: session
+        } as TabItem;
 
         set({
           tabs: tabs
         });
         syncTabs();
       },
-      focusPreviewTab: (
-        noteId: string,
-        options: Omit<Partial<TabItem>, "id" | "noteId">
-      ) => {
-        const index = get().tabs.findIndex((t) => t.previewTab);
-        if (index === -1)
-          return get().newTab({
-            noteId,
-            previewTab: true,
-            ...options
-          });
+      updateTab: (id: string, 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,
-          previewTab: true,
-          noteId: noteId
-        };
-        console.log("focus preview", noteId);
+          session: updatedSession
+        } as TabItem;
+
         set({
           tabs: tabs
         });
-        get().focusTab(tabs[index].id);
+        syncTabs();
       },
-      removeTab: (id: number) => {
-        const index = get().tabs.findIndex((t) => t.id === id);
+      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) {
+          tabSessionHistory.remove(currentTab, id);
+          TabSessionStorage.remove(id);
+          if (!tabSessionHistory.canGoBack(currentTab)) {
+            tabSessionHistory.forward(currentTab);
+            syncTabs();
+          } else {
+            return get().goBack();
+          }
+        } 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))) {
+          tabSessionHistory.remove(currentTab, id);
+          TabSessionStorage.remove(id);
+          if (!tabSessionHistory.canGoForward(currentTab)) {
+            tabSessionHistory.back(currentTab);
+            syncTabs();
+          } else {
+            return get().goForward();
+          }
+        } 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.locked = isLocked;
+          session.noteLocked = isLocked && !session?.noteLocked;
+
+          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.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) {
-            nextTabs.push({
-              id: 0
+            const id = getId();
+            set({
+              tabs: [{ id: id }]
             });
+            get().newTabSession(id, {});
+            get().focusTab(id);
+          } else {
+            set({
+              tabs: nextTabs
+            });
+            if (isFocused) {
+              const lastTab = history.restoreLast();
+              if (lastTab) get().focusTab(lastTab);
+            }
           }
-          set({
-            tabs: nextTabs
-          });
-          get().focusTab(
-            isFocused ? history.restoreLast() || 0 : get().currentTab
-          );
+          syncTabs();
         }
       },
       newTab: (options) => {
-        const id = getId(get().tabs.length, get().tabs);
-        const nextTabs = [
-          ...get().tabs,
-          {
-            id: id,
-            ...options
-          }
-        ];
+        const id = getId();
         set({
-          tabs: nextTabs
+          tabs: [
+            ...get().tabs,
+            {
+              id: id,
+              ...options
+            }
+          ]
         });
+        get().newTabSession(id, options?.session || {});
         get().focusTab(id);
+        return id;
       },
       focusEmptyTab: () => {
-        const index = get().tabs.findIndex((t) => !t.noteId);
+        const index = get().tabs.findIndex((t) => !t.session?.noteId);
         if (index === -1) return get().newTab();
-        console.log("focus empty tab", get().tabs[index]);
 
         get().focusTab(get().tabs[index].id);
       },
@@ -224,38 +439,46 @@ export const useTabStore = create<TabStore>(
         syncTabs();
       },
 
-      focusTab: (id: number) => {
-        console.log(history.getHistory(), id);
+      focusTab: (id: string) => {
         history.add(id);
         set({
-          currentTab: id
+          currentTab: id,
+          canGoBack: tabSessionHistory.canGoBack(id),
+          canGoForward: tabSessionHistory.canGoForward(id),
+          sessionId: tabSessionHistory.currentSessionId(id)
         });
         syncTabs();
       },
-      getNoteIdForTab: (id: number) => {
-        return get().tabs.find((t) => t.id === id)?.noteId;
+      getNoteIdForTab: (id: string) => {
+        return get().tabs.find((t) => t.id === id)?.session?.noteId;
       },
       hasTabForNote: (noteId: string) => {
-        return (
-          typeof get().tabs.find((t) => t.noteId === noteId)?.id === "number"
-        );
+        return !!get().tabs.find((t) => t.session?.noteId === noteId);
       },
       getTabForNote: (noteId: string) => {
-        return get().tabs.find((t) => t.noteId === noteId)?.id;
+        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);
       },
       getCurrentNoteId: () => {
-        return get().tabs.find((t) => t.id === get().currentTab)?.noteId;
+        return get().tabs.find((t) => t.id === get().currentTab)?.session
+          ?.noteId;
       },
       getTab: (tabId) => {
         return get().tabs.find((t) => t.id === tabId);
       }
     }),
     {
-      name: "tabs-storage",
+      name: "tabs-storage-v3",
       getStorage: () => MMKV as unknown as StateStorage,
       onRehydrateStorage: () => {
         return (state) => {
-          history.history = state?.tabHistory.slice() || [];
+          history.history = state?.historyNew || [];
         };
       }
     }

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

@@ -31,6 +31,8 @@ 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>;
@@ -46,19 +48,6 @@ 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)
@@ -72,15 +61,15 @@ export function makeSessionId(id?: string) {
 export async function isEditorLoaded(
   ref: RefObject<WebView>,
   sessionId: string,
-  tabId: number
+  tabId: string
 ) {
-  return await post(ref, sessionId, tabId, EditorEvents.status);
+  return await post(ref, sessionId, tabId, NativeEvents.status);
 }
 
 export async function post<T>(
   ref: RefObject<WebView>,
   sessionId: string,
-  tabId: number,
+  tabId: string,
   type: string,
   value: T | null = null,
   waitFor = 300
@@ -135,7 +124,6 @@ export const waitForEvent = async (
     };
     eSubscribeEvent(type, callback);
     setTimeout(() => {
-      console.log("return..");
       eUnSubscribeEvent(type, callback);
       resolve(false);
     }, waitFor);
@@ -158,6 +146,9 @@ 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();
@@ -183,7 +174,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/home/index.tsx

@@ -52,7 +52,7 @@ export const Home = ({ navigation, route }: NavigationProps<"Notes">) => {
       <SelectionHeader id={route.name} items={notes} type="note" />
       <Header
         renderedInRoute={route.name}
-        title={strings.routes[route.name as keyof typeof strings.routes]()}
+        title={strings.routes[route.name]()}
         canGoBack={false}
         hasSearch={true}
         onSearch={() => {
@@ -72,9 +72,7 @@ export const Home = ({ navigation, route }: NavigationProps<"Notes">) => {
           dataType="note"
           renderedInRoute={route.name}
           loading={loading || !isFocused}
-          headerTitle={strings.routes[
-            route.name as keyof typeof strings.routes
-          ]?.()}
+          headerTitle={strings.routes[route.name]()}
           placeholder={{
             title: route.name?.toLowerCase(),
             paragraph: strings.notesEmpty(),

apps/mobile/app/screens/note-preview-configure/index.tsx

@@ -0,0 +1,169 @@
+/*
+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,14 +284,13 @@ 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,7 +59,6 @@ ColoredNotes.navigate = (item: Color, canGoBack: boolean) => {
   const { focusedRouteId } = useNavigationStore.getState();
 
   if (focusedRouteId === item.id) {
-    console.log("ColoredNotes.navigate: route already focused for color");
     return;
   }
 

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

@@ -171,7 +171,6 @@ const NotesPage = ({
           setLoadingNotes(false);
         })
         .catch((e) => {
-          console.log("Error loading notes", params.current?.title, e, e.stack);
           setLoadingNotes(false);
         });
     }
@@ -196,8 +195,7 @@ const NotesPage = ({
       <Header
         renderedInRoute={route.name}
         title={
-          title ||
-          strings.routes[route.name as unknown as keyof typeof strings.routes]()
+          route.name === "Monographs" ? strings.routes[route.name]() : title
         }
         canGoBack={params?.current?.canGoBack}
         hasSearch={true}

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

@@ -60,7 +60,6 @@ TaggedNotes.navigate = (item: Tag, canGoBack?: boolean) => {
   const { focusedRouteId } = useNavigationStore.getState();
 
   if (focusedRouteId === item.id) {
-    console.log("TaggedNotes.navigate: route already focused for tag");
     return;
   }
 

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

@@ -91,7 +91,6 @@ export const Reminders = ({
         />
 
         <FloatingButton
-          title={strings.setReminder()}
           onPress={() => {
             ReminderSheet.present();
           }}

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

@@ -59,15 +59,38 @@ export const Search = ({ route, navigation }: NavigationProps<"Search">) => {
       }
       try {
         setLoading(true);
-        const type =
-          route.params.type === "trash"
-            ? "trash"
-            : ((route.params?.type + "s") as keyof typeof db.lookup);
-        console.log(`Searching in ${type} for ${query}`);
-        const results = await db.lookup[type](
-          query,
-          route.params.items as FilteredSelector<Note>
-        ).sorted();
+        let results: VirtualizedGrouping<Item> | undefined;
+
+        switch (route.params.type) {
+          case "note":
+            results = await db.lookup
+              .notes(query, route.params.items as FilteredSelector<Note>)
+              .sorted();
+            break;
+          case "notebook":
+            results = await db.lookup.notebooks(query).sorted();
+            break;
+          case "tag":
+            results = await db.lookup.tags(query).sorted();
+            break;
+          case "reminder":
+            results = await db.lookup.reminders(query).sorted();
+            break;
+          case "trash":
+            results = await db.lookup.trash(query).sorted();
+            break;
+          case "attachment":
+            results = await db.lookup.attachments(query).sorted();
+            break;
+          default:
+            results = undefined;
+        }
+
+        if (!results) {
+          setSearchStatus(strings.noResultsFound(query));
+          setLoading(false);
+          return;
+        }
 
         console.log(
           `Found ${results.placeholders?.length} results for ${query}`

apps/mobile/app/screens/settings/2fa.tsx

@@ -17,6 +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/>.
 */
 
+import { sanitizeFilename } from "@notesnook/common";
+import { strings } from "@notesnook/intl";
+import { useThemeColors, VariantsWithStaticColors } from "@notesnook/theme";
 import Clipboard from "@react-native-clipboard/clipboard";
 import React, {
   Dispatch,
@@ -26,11 +29,11 @@ import React, {
   useState
 } from "react";
 import { ActivityIndicator, Linking, Platform, View } from "react-native";
+import RNFetchBlob from "react-native-blob-util";
 import { FlatList } from "react-native-gesture-handler";
 import * as ScopedStorage from "react-native-scoped-storage";
-import RNFetchBlob from "react-native-blob-util";
 import { db } from "../../common/database";
-import Storage from "../../common/database/storage";
+import filesystem from "../../common/filesystem";
 import DialogHeader from "../../components/dialog/dialog-header";
 import { Button } from "../../components/ui/button";
 import { IconButton } from "../../components/ui/icon-button";
@@ -46,13 +49,10 @@ import {
   presentSheet,
   ToastManager
 } from "../../services/event-manager";
-import { useThemeColors, VariantsWithStaticColors } from "@notesnook/theme";
 import { useUserStore } from "../../stores/use-user-store";
 import { eCloseSheet } from "../../utils/events";
 import { SIZE } from "../../utils/size";
 import { sleep } from "../../utils/time";
-import { sanitizeFilename } from "@notesnook/common";
-import { strings } from "@notesnook/intl";
 const mfaMethods: MFAMethod[] = [
   {
     id: "app",
@@ -525,7 +525,7 @@ export const MFARecoveryCodes = ({
                     if (!file) return;
                     path = file.uri;
                   } else {
-                    path = await Storage.checkAndCreateDir("/");
+                    path = await filesystem.checkAndCreateDir("/");
                     await RNFetchBlob.fs.writeFile(
                       path + fileName,
                       codeString,

apps/mobile/app/screens/settings/debug.tsx

@@ -17,24 +17,24 @@ 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 Clipboard from "@react-native-clipboard/clipboard";
-import { LogMessage } from "@notesnook/logger";
+import { sanitizeFilename } from "@notesnook/common";
 import { format, LogLevel, logManager } from "@notesnook/core";
+import { strings } from "@notesnook/intl";
+import { LogMessage } from "@notesnook/logger";
+import { useThemeColors } from "@notesnook/theme";
+import Clipboard from "@react-native-clipboard/clipboard";
 import React, { useEffect, useRef, useState } from "react";
 import { FlatList, Platform, TouchableOpacity, View } from "react-native";
-import * as ScopedStorage from "react-native-scoped-storage";
 import RNFetchBlob from "react-native-blob-util";
-import Storage from "../../common/database/storage";
+import * as ScopedStorage from "react-native-scoped-storage";
+import filesystem from "../../common/filesystem";
 import { presentDialog } from "../../components/dialog/functions";
 import { IconButton } from "../../components/ui/icon-button";
 import { Notice } from "../../components/ui/notice";
 import Paragraph from "../../components/ui/typography/paragraph";
 import useTimer from "../../hooks/use-timer";
 import { ToastManager } from "../../services/event-manager";
-import { useThemeColors } from "@notesnook/theme";
 import { hexToRGBA } from "../../utils/colors";
-import { sanitizeFilename } from "@notesnook/common";
-import { strings } from "@notesnook/intl";
 
 export default function DebugLogs() {
   const { colors } = useThemeColors();
@@ -148,7 +148,7 @@ export default function DebugLogs() {
         if (!file) return;
         path = file.uri;
       } else {
-        path = await Storage.checkAndCreateDir("/");
+        path = await filesystem.checkAndCreateDir("/");
         await RNFetchBlob.fs.writeFile(path + fileName + ".txt", data, "utf8");
         path = path + fileName;
       }
@@ -160,9 +160,7 @@ export default function DebugLogs() {
           type: "success"
         });
       }
-    } catch (e) {
-      console.log(e);
-    }
+    } catch (e) {}
   }, [currentLog?.logs]);
 
   const copyLogs = React.useCallback(() => {

apps/mobile/app/screens/settings/home.tsx

@@ -45,7 +45,7 @@ const Home = ({
   });
 
   const renderItem = ({ item }: { item: SettingSection; index: number }) =>
-    item.name === "account" ? (
+    item.id === "account" ? (
       <SettingsUserSection item={item} />
     ) : (
       <SectionGroup item={item} />

apps/mobile/app/screens/settings/licenses.tsx

@@ -54,7 +54,9 @@ export const Licenses = () => {
         }}
         onPress={() => {
           if (!item.link) return;
-          Linking.openURL(item.link).catch(console.log);
+          Linking.openURL(item.link).catch(() => {
+            /* empty */
+          });
         }}
       >
         <Heading size={SIZE.sm}>{item.name}</Heading>

apps/mobile/app/screens/settings/picker/pickers.jsx

@@ -33,7 +33,6 @@ import { strings } from "@notesnook/intl";
 export const FontPicker = createSettingsPicker({
   getValue: () => useSettingStore.getState().settings.defaultFontFamily,
   updateValue: (item) => {
-    console.log(item.id);
     SettingsService.set({
       defaultFontFamily: item.id
     });
@@ -57,7 +56,7 @@ export const HomePicker = createSettingsPicker({
     });
   },
   formatValue: (item) => {
-    return strings.routes[typeof item === "object" ? item.name : item]();
+    return strings.routes[typeof item === "object" ? item.name : item]?.();
   },
   getItemKey: (item) => item.name,
   options: MenuItemsList.slice(0, MenuItemsList.length - 1),
@@ -75,7 +74,7 @@ export const TrashIntervalPicker = createSettingsPicker({
       ? strings.never()
       : item === 1
       ? strings.reminderRecurringMode.day()
-      : item + " " + strings.days();
+      : strings.days(item);
   },
   getItemKey: (item) => item.toString(),
   options: [-1, 1, 7, 30, 365],

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

@@ -28,7 +28,7 @@ import DocumentPicker from "react-native-document-picker";
 import * as ScopedStorage from "react-native-scoped-storage";
 import { unzip } from "react-native-zip-archive";
 import { DatabaseLogger, db } from "../../../common/database";
-import storage from "../../../common/database/storage";
+import filesystem from "../../../common/filesystem";
 import { deleteCacheFileByName } from "../../../common/filesystem/io";
 import { cacheDir, copyFileAsync } from "../../../common/filesystem/utils";
 import { presentDialog } from "../../../components/dialog/functions";
@@ -197,7 +197,6 @@ const restoreBackup = async (options: {
         const attachment = await db.attachments.attachment(hash as string);
         if (!attachment) continue;
 
-        console.log("Saving attachment file", hash);
         await deleteCacheFileByName(hash);
         await RNFetchBlob.fs.cp(
           `${zipOutputFolder}/attachments/${hash}`,
@@ -208,9 +207,13 @@ const restoreBackup = async (options: {
         progress: strings.cleaningUp()
       });
       // Remove files from cache
-      RNFetchBlob.fs.unlink(zipOutputFolder).catch(console.log);
+      RNFetchBlob.fs.unlink(zipOutputFolder).catch(() => {
+        /* empty */
+      });
       if (Platform.OS === "android" || deleteBackupFile) {
-        RNFetchBlob.fs.unlink(filePath).catch(console.log);
+        RNFetchBlob.fs.unlink(filePath).catch(() => {
+          /* empty */
+        });
       }
     } else {
       updateProgress({
@@ -300,7 +303,7 @@ export const RestoreBackup = () => {
           return;
         }
       } else {
-        const path = await storage.checkAndCreateDir("/backups/");
+        const path = await filesystem.checkAndCreateDir("/backups/");
         files = await RNFetchBlob.fs.lstat(path);
       }
       files = files

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

@@ -44,7 +44,12 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
   const settings = useSettingStore((state) => state.settings);
   const navigation = useNavigation<NavigationProp<RouteParams>>();
   const current = item.useHook && item.useHook(item);
-  const isHidden = item.hidden && item.hidden(item.property || current);
+  const [isHidden, setIsHidden] = useState(
+    item.hidden && item.hidden(item.property || current)
+  );
+  const [isDisabled, setIsDisabled] = useState(
+    item.disabled && item.disabled(item.property || current)
+  );
   const inputRef = useRef<TextInput>(null);
   const [loading, setLoading] = useState(false);
 
@@ -62,7 +67,13 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
     SettingsService.set({
       [item.property]: nextValue
     });
-    setImmediate(() => item.onChange?.(nextValue));
+    setImmediate(() => {
+      item.onChange?.(nextValue);
+      item.hidden &&
+        setIsHidden(item.hidden && item.hidden(item.property || current));
+      item.disabled &&
+        setIsDisabled(item.disabled && item.disabled(item.property || current));
+    });
   };
 
   const styles =
@@ -94,7 +105,7 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
 
   return isHidden ? null : (
     <Pressable
-      disabled={item.type === "component"}
+      disabled={item.type === "component" || isDisabled}
       style={{
         width: "100%",
         alignItems: "center",
@@ -102,10 +113,12 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
         flexDirection: "row",
         justifyContent: "space-between",
         paddingVertical: 20,
+        opacity: isDisabled ? 0.5 : 1,
         borderRadius: 0,
         ...styles
       }}
       onPress={async () => {
+        if (isDisabled) return;
         switch (item.type) {
           case "screen":
             {
@@ -203,19 +216,16 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
             <Input
               {...item.inputProperties}
               onSubmit={(e) => {
-                if (e.nativeEvent.text) {
-                  SettingsService.set({
-                    [item.property as string]: e.nativeEvent.text
-                  });
-                }
+                SettingsService.set({
+                  [item.property as string]: e.nativeEvent.text
+                });
                 item.inputProperties?.onSubmitEditing?.(e);
               }}
+              editable={!isDisabled}
               onChangeText={(text) => {
-                if (text) {
-                  SettingsService.set({
-                    [item.property as string]: text
-                  });
-                }
+                SettingsService.set({
+                  [item.property as string]: text
+                });
                 item.inputProperties?.onSubmitEditing?.(text as any);
               }}
               containerStyle={{ marginTop: 12 }}
@@ -244,6 +254,7 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
                 name="minus"
                 color={colors.primary.icon}
                 onPress={() => {
+                  if (isDisabled) return;
                   const rawValue = SettingsService.get()[
                     item.property as keyof SettingStore["settings"]
                   ] as string;
@@ -266,6 +277,7 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
                   onChangeInputSelectorValue(e.nativeEvent.text);
                   item.inputProperties?.onSubmitEditing?.(e);
                 }}
+                editable={!isDisabled}
                 onChangeText={(text) => {
                   onChangeInputSelectorValue(text);
                   item.inputProperties?.onSubmitEditing?.(text as any);
@@ -291,6 +303,7 @@ const _SectionItem = ({ item }: { item: SettingSection }) => {
                 name="plus"
                 color={colors.primary.icon}
                 onPress={() => {
+                  if (isDisabled) return;
                   const rawValue = SettingsService.get()[
                     item.property as keyof SettingStore["settings"]
                   ] as string;