release 0.46.9

(cherry picked from commit 51d1d8efb8)

.idea/vcs.xml

@@ -2,6 +2,5 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
   </component>
 </project>

README.md

@@ -55,3 +55,7 @@ npm run start-server
 * [FancyTree](https://github.com/mar10/fancytree) - very feature rich tree library without real competition. Trilium Notes would not be the same without it.
 * [CodeMirror](https://github.com/codemirror/CodeMirror) - code editor with support for huge amount of languages
 * [jsPlumb](https://github.com/jsplumb/jsplumb) - visual connectivity library without competition. Used in [relation maps](https://github.com/zadam/trilium/wiki/Relation-map) and [link maps](https://github.com/zadam/trilium/wiki/Link-map)
+
+## License
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

bin/build-server.sh

@@ -10,7 +10,7 @@ fi
 
 cd dist
 wget https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.xz
-tar xvfJ node-v${NODE_VERSION}-linux-x64.tar.xz
+tar xfJ node-v${NODE_VERSION}-linux-x64.tar.xz
 rm node-v${NODE_VERSION}-linux-x64.tar.xz
 cd ..
 

bin/copy-trilium.sh

@@ -5,7 +5,7 @@ if [[ $# -eq 0 ]] ; then
     exit 1
 fi
 
-npm run webpack
+n exec 12 npm run webpack
 
 DIR=$1
 
@@ -27,7 +27,7 @@ cp -r electron.js $DIR/
 cp webpack-* $DIR/
 
 # run in subshell (so we return to original dir)
-(cd $DIR && npm install --only=prod)
+(cd $DIR && n exec 12 npm install --only=prod)
 
 # cleanup of useless files in dependencies
 rm -r $DIR/node_modules/image-q/demo

bin/release.sh

@@ -55,47 +55,20 @@ echo "Creating release in GitHub"
 EXTRA=
 
 if [[ $TAG == *"beta"* ]]; then
-  EXTRA=--pre-release
+  EXTRA=--prerelease
 fi
 
-github-release release \
+echo "$GITHUB_CLI_AUTH_TOKEN" | gh auth login --with-token
-    --tag $TAG \
-    --name "$TAG release" $EXTRA
 
-echo "Uploading debian x64 package"
+gh release create "$TAG" \
-
+    --title "$TAG release" \
-github-release upload \
+    --notes "" \
-    --tag $TAG \
+    $EXTRA \
-    --name "$DEBIAN_X64_BUILD" \
+    "dist/$DEBIAN_X64_BUILD" \
-    --file "dist/$DEBIAN_X64_BUILD"
+    "dist/$LINUX_X64_BUILD" \
-
+    "dist/$WINDOWS_X64_BUILD" \
-echo "Uploading linux x64 build"
+    "dist/$MAC_X64_BUILD" \
-
+    "dist/$SERVER_BUILD"
-github-release upload \
-    --tag $TAG \
-    --name "$LINUX_X64_BUILD" \
-    --file "dist/$LINUX_X64_BUILD"
-
-echo "Uploading windows x64 build"
-
-github-release upload \
-    --tag $TAG \
-    --name "$WINDOWS_X64_BUILD" \
-    --file "dist/$WINDOWS_X64_BUILD"
-
-echo "Uploading mac x64 build"
-
-github-release upload \
-    --tag $TAG \
-    --name "$MAC_X64_BUILD" \
-    --file "dist/$MAC_X64_BUILD"
-
-echo "Uploading linux x64 server build"
-
-github-release upload \
-    --tag $TAG \
-    --name "$SERVER_BUILD" \
-    --file "dist/$SERVER_BUILD"
 
 echo "Building docker image"
 

package.json

@@ -2,7 +2,7 @@
   "name": "trilium",
   "productName": "Trilium Notes",
   "description": "Trilium Notes",
-  "version": "0.46.2-beta",
+  "version": "0.46.9",
   "license": "AGPL-3.0-only",
   "main": "electron.js",
   "bin": {
@@ -14,7 +14,7 @@
   },
   "scripts": {
     "start-server": "cross-env TRILIUM_ENV=dev node ./src/www",
-    "start-electron": "cross-env TRILIUM_ENV=dev electron .",
+    "start-electron": "cross-env TRILIUM_ENV=dev electron --inspect=5858 .",
     "build-backend-docs": "./node_modules/.bin/jsdoc -c jsdoc-conf.json -d ./docs/backend_api src/entities/*.js src/services/backend_script_api.js",
     "build-frontend-docs": "./node_modules/.bin/jsdoc -c jsdoc-conf.json -d ./docs/frontend_api src/public/app/entities/*.js src/public/app/services/frontend_script_api.js src/public/app/widgets/collapsible_widget.js",
     "build-docs": "npm run build-backend-docs && npm run build-frontend-docs",
@@ -35,7 +35,7 @@
     "dayjs": "1.10.4",
     "ejs": "3.1.6",
     "electron-debug": "3.2.0",
-    "electron-dl": "3.1.0",
+    "electron-dl": "3.2.0",
     "electron-find": "1.0.6",
     "electron-window-state": "5.0.3",
     "express": "4.17.1",
@@ -51,10 +51,11 @@
     "is-animated": "^2.0.1",
     "is-svg": "4.2.1",
     "jimp": "0.16.1",
-    "jsdom": "^16.4.0",
+    "joplin-turndown-plugin-gfm": "1.0.12",
+    "jsdom": "16.5.0",
     "mime-types": "2.1.29",
     "multer": "1.4.2",
-    "node-abi": "2.19.3",
+    "node-abi": "2.26.0",
     "open": "7.4.2",
     "portscanner": "2.2.0",
     "rand-token": "1.0.1",
@@ -70,16 +71,15 @@
     "striptags": "3.1.1",
     "tmp": "^0.2.1",
     "turndown": "7.0.0",
-    "joplin-turndown-plugin-gfm": "1.0.12",
     "unescape": "1.0.1",
-    "ws": "7.4.3",
+    "ws": "7.4.4",
     "yauzl": "2.10.0",
     "yazl": "2.5.1"
   },
   "devDependencies": {
     "cross-env": "7.0.3",
-    "electron": "9.4.3",
+    "electron": "9.4.4",
-    "electron-builder": "22.9.1",
+    "electron-builder": "22.10.5",
     "electron-packager": "15.2.0",
     "electron-rebuild": "2.3.5",
     "esm": "3.2.25",
@@ -87,7 +87,7 @@
     "jsdoc": "3.6.6",
     "lorem-ipsum": "2.0.3",
     "rcedit": "3.0.0",
-    "webpack": "5.24.2",
+    "webpack": "5.24.4",
     "webpack-cli": "4.5.0"
   },
   "optionalDependencies": {

spec/search/lexer.spec.js

@@ -87,14 +87,16 @@ describe("Lexer expression", () => {
             .toEqual(["#label", "*=*", "text"]);
     });
 
-    it("simple label operator with in quotes and without", () => {
+    it("simple label operator with in quotes", () => {
         expect(lex("#label*=*'text'").expressionTokens)
             .toEqual([
                 {token: "#label", inQuotes: false, startIndex: 0, endIndex: 5},
                 {token: "*=*", inQuotes: false, startIndex: 6, endIndex: 8},
                 {token: "text", inQuotes: true, startIndex: 10, endIndex: 13}
             ]);
+    });
 
+    it("simple label operator with param without quotes", () => {
         expect(lex("#label*=*text").expressionTokens)
             .toEqual([
                 {token: "#label", inQuotes: false, startIndex: 0, endIndex: 5},
@@ -103,6 +105,16 @@ describe("Lexer expression", () => {
             ]);
     });
 
+    it("simple label operator with empty string param", () => {
+        expect(lex("#label = ''").expressionTokens)
+            .toEqual([
+                {token: "#label", inQuotes: false, startIndex: 0, endIndex: 5},
+                {token: "=", inQuotes: false, startIndex: 7, endIndex: 7},
+                // weird case for empty strings which ends up with endIndex < startIndex :-(
+                {token: "", inQuotes: true, startIndex: 10, endIndex: 9}
+            ]);
+    });
+
     it("note. prefix also separates fulltext from expression", () => {
         expect(lex(`hello fulltext note.labels.capital = Prague`).expressionTokens.map(t => t.token))
             .toEqual(["note", ".", "labels", ".", "capital", "=", "prague"]);

spec/search/parser.spec.js

@@ -19,6 +19,13 @@ function tokens(toks, cur = 0) {
     });
 }
 
+function assertIsArchived(exp) {
+    expect(exp.constructor.name).toEqual("PropertyComparisonExp");
+    expect(exp.propertyName).toEqual("isArchived");
+    expect(exp.operator).toEqual("=");
+    expect(exp.comparedValue).toEqual("false");
+}
+
 describe("Parser", () => {
     it("fulltext parser without content", () => {
         const rootExp = parse({
@@ -29,8 +36,9 @@ describe("Parser", () => {
 
         expect(rootExp.constructor.name).toEqual("AndExp");
         expect(rootExp.subExpressions[0].constructor.name).toEqual("PropertyComparisonExp");
-        expect(rootExp.subExpressions[1].constructor.name).toEqual("NoteCacheFlatTextExp");
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("OrExp");
-        expect(rootExp.subExpressions[1].tokens).toEqual(["hello", "hi"]);
+        expect(rootExp.subExpressions[1].subExpressions[0].constructor.name).toEqual("NoteCacheFlatTextExp");
+        expect(rootExp.subExpressions[1].subExpressions[0].tokens).toEqual(["hello", "hi"]);
     });
 
     it("fulltext parser with content", () => {
@@ -40,9 +48,12 @@ describe("Parser", () => {
             searchContext: new SearchContext({includeNoteContent: true})
         });
 
-        expect(rootExp.constructor.name).toEqual("OrExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
+        assertIsArchived(rootExp.subExpressions[0]);
 
-        const subs = rootExp.subExpressions;
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("OrExp");
+
+        const subs = rootExp.subExpressions[1].subExpressions;
 
         expect(subs[0].constructor.name).toEqual("NoteCacheFlatTextExp");
         expect(subs[0].tokens).toEqual(["hello", "hi"]);
@@ -61,10 +72,12 @@ describe("Parser", () => {
             searchContext: new SearchContext()
         });
 
-        expect(rootExp.constructor.name).toEqual("LabelComparisonExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
-        expect(rootExp.attributeType).toEqual("label");
+        assertIsArchived(rootExp.subExpressions[0]);
-        expect(rootExp.attributeName).toEqual("mylabel");
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("LabelComparisonExp");
-        expect(rootExp.comparator).toBeTruthy();
+        expect(rootExp.subExpressions[1].attributeType).toEqual("label");
+        expect(rootExp.subExpressions[1].attributeName).toEqual("mylabel");
+        expect(rootExp.subExpressions[1].comparator).toBeTruthy();
     });
 
     it("simple attribute negation", () => {
@@ -74,10 +87,12 @@ describe("Parser", () => {
             searchContext: new SearchContext()
         });
 
-        expect(rootExp.constructor.name).toEqual("NotExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
-        expect(rootExp.subExpression.constructor.name).toEqual("AttributeExistsExp");
+        assertIsArchived(rootExp.subExpressions[0]);
-        expect(rootExp.subExpression.attributeType).toEqual("label");
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("NotExp");
-        expect(rootExp.subExpression.attributeName).toEqual("mylabel");
+        expect(rootExp.subExpressions[1].subExpression.constructor.name).toEqual("AttributeExistsExp");
+        expect(rootExp.subExpressions[1].subExpression.attributeType).toEqual("label");
+        expect(rootExp.subExpressions[1].subExpression.attributeName).toEqual("mylabel");
 
         rootExp = parse({
             fulltextTokens: [],
@@ -85,10 +100,12 @@ describe("Parser", () => {
             searchContext: new SearchContext()
         });
 
-        expect(rootExp.constructor.name).toEqual("NotExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
-        expect(rootExp.subExpression.constructor.name).toEqual("AttributeExistsExp");
+        assertIsArchived(rootExp.subExpressions[0]);
-        expect(rootExp.subExpression.attributeType).toEqual("relation");
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("NotExp");
-        expect(rootExp.subExpression.attributeName).toEqual("myrelation");
+        expect(rootExp.subExpressions[1].subExpression.constructor.name).toEqual("AttributeExistsExp");
+        expect(rootExp.subExpressions[1].subExpression.attributeType).toEqual("relation");
+        expect(rootExp.subExpressions[1].subExpression.attributeName).toEqual("myrelation");
     });
 
     it("simple label AND", () => {
@@ -99,7 +116,10 @@ describe("Parser", () => {
         });
 
         expect(rootExp.constructor.name).toEqual("AndExp");
-        const [firstSub, secondSub] = rootExp.subExpressions;
+        assertIsArchived(rootExp.subExpressions[0]);
+
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("AndExp");
+        const [firstSub, secondSub] = rootExp.subExpressions[1].subExpressions;
 
         expect(firstSub.constructor.name).toEqual("LabelComparisonExp");
         expect(firstSub.attributeName).toEqual("first");
@@ -116,7 +136,10 @@ describe("Parser", () => {
         });
 
         expect(rootExp.constructor.name).toEqual("AndExp");
-        const [firstSub, secondSub] = rootExp.subExpressions;
+        assertIsArchived(rootExp.subExpressions[0]);
+
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("AndExp");
+        const [firstSub, secondSub] = rootExp.subExpressions[1].subExpressions;
 
         expect(firstSub.constructor.name).toEqual("LabelComparisonExp");
         expect(firstSub.attributeName).toEqual("first");
@@ -132,8 +155,11 @@ describe("Parser", () => {
             searchContext: new SearchContext()
         });
 
-        expect(rootExp.constructor.name).toEqual("OrExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
-        const [firstSub, secondSub] = rootExp.subExpressions;
+        assertIsArchived(rootExp.subExpressions[0]);
+
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("OrExp");
+        const [firstSub, secondSub] = rootExp.subExpressions[1].subExpressions;
 
         expect(firstSub.constructor.name).toEqual("LabelComparisonExp");
         expect(firstSub.attributeName).toEqual("first");
@@ -155,8 +181,9 @@ describe("Parser", () => {
         expect(firstSub.constructor.name).toEqual("PropertyComparisonExp");
         expect(firstSub.propertyName).toEqual('isArchived');
 
-        expect(secondSub.constructor.name).toEqual("NoteCacheFlatTextExp");
+        expect(secondSub.constructor.name).toEqual("OrExp");
-        expect(secondSub.tokens).toEqual(["hello"]);
+        expect(secondSub.subExpressions[0].constructor.name).toEqual("NoteCacheFlatTextExp");
+        expect(secondSub.subExpressions[0].tokens).toEqual(["hello"]);
 
         expect(thirdSub.constructor.name).toEqual("LabelComparisonExp");
         expect(thirdSub.attributeName).toEqual("mylabel");
@@ -169,8 +196,11 @@ describe("Parser", () => {
             searchContext: new SearchContext()
         });
 
-        expect(rootExp.constructor.name).toEqual("OrExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
-        const [firstSub, secondSub] = rootExp.subExpressions;
+        assertIsArchived(rootExp.subExpressions[0]);
+
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("OrExp");
+        const [firstSub, secondSub] = rootExp.subExpressions[1].subExpressions;
 
         expect(firstSub.constructor.name).toEqual("LabelComparisonExp");
         expect(firstSub.attributeName).toEqual("first");
@@ -232,10 +262,12 @@ describe("Invalid expressions", () => {
             searchContext: new SearchContext()
         });
 
-        expect(rootExp.constructor.name).toEqual("LabelComparisonExp");
+        expect(rootExp.constructor.name).toEqual("AndExp");
-        expect(rootExp.attributeType).toEqual("label");
+        assertIsArchived(rootExp.subExpressions[0]);
-        expect(rootExp.attributeName).toEqual("first");
+        expect(rootExp.subExpressions[1].constructor.name).toEqual("LabelComparisonExp");
-        expect(rootExp.comparator).toBeTruthy();
+        expect(rootExp.subExpressions[1].attributeType).toEqual("label");
+        expect(rootExp.subExpressions[1].attributeName).toEqual("first");
+        expect(rootExp.subExpressions[1].comparator).toBeTruthy();
     });
 
     it("searching by relation without note property", () => {

spec/search/search.spec.js

@@ -562,8 +562,8 @@ describe("Search", () => {
         expect(noteCache.notes[searchResults[0].noteId].title).toEqual("Austria");
         expect(noteCache.notes[searchResults[1].noteId].title).toEqual("Italy");
 
-        searchResults = searchService.findNotesWithQuery('# note.parents.title = Europe orderBy #capital DESC limit 0', searchContext);
+        searchResults = searchService.findNotesWithQuery('# note.parents.title = Europe orderBy #capital DESC limit 1', searchContext);
-        expect(searchResults.length).toEqual(0);
+        expect(searchResults.length).toEqual(1);
 
         searchResults = searchService.findNotesWithQuery('# note.parents.title = Europe orderBy #capital DESC limit 1000', searchContext);
         expect(searchResults.length).toEqual(4);

spec/search/value_extractor.spec.js

@@ -1,6 +1,9 @@
 const {note} = require('./note_cache_mocking.js');
 const ValueExtractor = require('../../src/services/search/value_extractor.js');
 const noteCache = require('../../src/services/note_cache/note_cache.js');
+const SearchContext = require("../../src/services/search/search_context.js");
+
+const dsc = new SearchContext();
 
 describe("Value extractor", () => {
     beforeEach(() => {
@@ -10,7 +13,7 @@ describe("Value extractor", () => {
     it("simple title extraction", async () => {
         const europe = note("Europe").note;
 
-        const valueExtractor = new ValueExtractor(["note", "title"]);
+        const valueExtractor = new ValueExtractor(dsc, ["note", "title"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(europe)).toEqual("Europe");
@@ -21,12 +24,12 @@ describe("Value extractor", () => {
             .label("Capital", "Vienna")
             .note;
 
-        let valueExtractor = new ValueExtractor(["note", "labels", "capital"]);
+        let valueExtractor = new ValueExtractor(dsc, ["note", "labels", "capital"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(austria)).toEqual("Vienna");
 
-        valueExtractor = new ValueExtractor(["#capital"]);
+        valueExtractor = new ValueExtractor(dsc, ["#capital"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(austria)).toEqual("Vienna");
@@ -38,12 +41,12 @@ describe("Value extractor", () => {
             .child(note("Austria")
                 .child(vienna));
 
-        let valueExtractor = new ValueExtractor(["note", "children", "children", "title"]);
+        let valueExtractor = new ValueExtractor(dsc, ["note", "children", "children", "title"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(europe.note)).toEqual("Vienna");
 
-        valueExtractor = new ValueExtractor(["note", "parents", "parents", "title"]);
+        valueExtractor = new ValueExtractor(dsc, ["note", "parents", "parents", "title"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(vienna.note)).toEqual("Europe");
@@ -56,12 +59,12 @@ describe("Value extractor", () => {
                 .relation('neighbor', czechRepublic.note)
                 .relation('neighbor', slovakia.note);
 
-        let valueExtractor = new ValueExtractor(["note", "relations", "neighbor", "labels", "capital"]);
+        let valueExtractor = new ValueExtractor(dsc, ["note", "relations", "neighbor", "labels", "capital"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(austria.note)).toEqual("Prague");
 
-        valueExtractor = new ValueExtractor(["~neighbor", "labels", "capital"]);
+        valueExtractor = new ValueExtractor(dsc, ["~neighbor", "labels", "capital"]);
 
         expect(valueExtractor.validate()).toBeFalsy();
         expect(valueExtractor.extract(austria.note)).toEqual("Prague");
@@ -70,17 +73,17 @@ describe("Value extractor", () => {
 
 describe("Invalid value extractor property path", () => {
     it('each path must start with "note" (or label/relation)',
-        () => expect(new ValueExtractor(["neighbor"]).validate()).toBeTruthy());
+        () => expect(new ValueExtractor(dsc, ["neighbor"]).validate()).toBeTruthy());
 
     it("extra path element after terminal label",
-        () => expect(new ValueExtractor(["~neighbor", "labels", "capital", "noteId"]).validate()).toBeTruthy());
+        () => expect(new ValueExtractor(dsc, ["~neighbor", "labels", "capital", "noteId"]).validate()).toBeTruthy());
 
     it("extra path element after terminal title",
-        () => expect(new ValueExtractor(["note", "title", "isProtected"]).validate()).toBeTruthy());
+        () => expect(new ValueExtractor(dsc, ["note", "title", "isProtected"]).validate()).toBeTruthy());
 
     it("relation name and note property is missing",
-        () => expect(new ValueExtractor(["note", "relations"]).validate()).toBeTruthy());
+        () => expect(new ValueExtractor(dsc, ["note", "relations"]).validate()).toBeTruthy());
 
     it("relation is specified but target note property is not specified",
-        () => expect(new ValueExtractor(["note", "relations", "myrel"]).validate()).toBeTruthy());
+        () => expect(new ValueExtractor(dsc, ["note", "relations", "myrel"]).validate()).toBeTruthy());
 });

src/entities/entity.js

@@ -41,7 +41,7 @@ class Entity {
     }
 
     getUtcDateChanged() {
-        return this.utcDateModified;
+        return this.utcDateModified || this.utcDateCreated;
     }
 
     get repository() {

src/entities/note.js

@@ -49,8 +49,13 @@ class Note extends Entity {
             this.isContentAvailable = protectedSessionService.isProtectedSessionAvailable();
 
             if (this.isContentAvailable) {
+                try {
                     this.title = protectedSessionService.decryptString(this.title);
                 }
+                catch (e) {
+                    throw new Error(`Could not decrypt title of note ${this.noteId}: ${e.message} ${e.stack}`)
+                }
+            }
             else {
                 this.title = "[protected]";
             }
@@ -156,14 +161,14 @@ class Note extends Entity {
 
         sql.upsert("note_contents", "noteId", pojo);
 
-        const hash = utils.hash(this.noteId + "|" + content.toString());
+        const hash = utils.hash(this.noteId + "|" + pojo.content.toString());
 
         entityChangesService.addEntityChange({
             entityName: 'note_contents',
             entityId: this.noteId,
             hash: hash,
             isErased: false,
-            utcDateChanged: this.getUtcDateChanged()
+            utcDateChanged: pojo.utcDateModified
         }, null);
     }
 
@@ -365,7 +370,6 @@ class Note extends Entity {
                 WHERE attributes.isDeleted = 0
                   AND attributes.type = 'relation'
                   AND attributes.name = 'template'
-                  AND (treeWithAttrs.level = 0 OR attributes.isInheritable = 1)
                 )
             SELECT attributes.* FROM attributes JOIN treeWithAttrs ON attributes.noteId = treeWithAttrs.noteId
             WHERE attributes.isDeleted = 0 AND (attributes.isInheritable = 1 OR treeWithAttrs.level = 0)

src/public/app/dialogs/options/appearance.js

@@ -29,6 +29,16 @@ const TPL = `
         </div>
     </div>
     
+    <div class="form-group row">
+        <div class="col-4">
+            <label for="heading-style">Heading style</label>
+            <select class="form-control" id="heading-style">
+                <option value="plain">Plain</option>
+                <option value="markdown">Markdown-style</option>
+            </select>
+        </div>
+    </div>
+
     <p>Zooming can be controlled with CTRL+- and CTRL+= shortcuts as well.</p>
 
     <h4>Font sizes</h4>
@@ -78,6 +88,7 @@ export default class ApperanceOptions {
         this.$themeSelect = $("#theme-select");
         this.$zoomFactorSelect = $("#zoom-factor-select");
         this.$nativeTitleBarSelect = $("#native-title-bar-select");
+        this.$headingStyle = $("#heading-style");
         this.$mainFontSize = $("#main-font-size");
         this.$treeFontSize = $("#tree-font-size");
         this.$detailFontSize = $("#detail-font-size");
@@ -86,11 +97,7 @@ export default class ApperanceOptions {
         this.$themeSelect.on('change', () => {
             const newTheme = this.$themeSelect.val();
 
-            for (const clazz of Array.from(this.$body[0].classList)) { // create copy to safely iterate over while removing classes
+            this.toggleBodyClass("theme-", newTheme);
-                if (clazz.startsWith("theme-")) {
-                    this.$body.removeClass(clazz);
-                }
-            }
 
             const noteId = $(this).find(":selected").attr("data-note-id");
 
@@ -100,8 +107,6 @@ export default class ApperanceOptions {
                 libraryLoader.requireCss(`api/notes/download/${noteId}`);
             }
 
-            this.$body.addClass("theme-" + newTheme);
-
             server.put('options/theme/' + newTheme);
         });
 
@@ -113,6 +118,14 @@ export default class ApperanceOptions {
             server.put('options/nativeTitleBarVisible/' + nativeTitleBarVisible);
         });
 
+        this.$headingStyle.on('change', () => {
+            const newHeadingStyle = this.$headingStyle.val();
+
+            this.toggleBodyClass("heading-style-", newHeadingStyle);
+
+            server.put('options/headingStyle/' + newHeadingStyle);
+        });
+
         this.$mainFontSize.on('change', async () => {
             await server.put('options/mainFontSize/' + this.$mainFontSize.val());
 
@@ -132,6 +145,16 @@ export default class ApperanceOptions {
         });
     }
 
+    toggleBodyClass(prefix, value) {
+        for (const clazz of Array.from(this.$body[0].classList)) { // create copy to safely iterate over while removing classes
+            if (clazz.startsWith(prefix)) {
+                this.$body.removeClass(clazz);
+            }
+        }
+
+        this.$body.addClass(prefix + value);
+    }
+
     async optionsLoaded(options) {
         const themes = [
             { val: 'white', title: 'White' },
@@ -159,6 +182,8 @@ export default class ApperanceOptions {
 
         this.$nativeTitleBarSelect.val(options.nativeTitleBarVisible === 'true' ? 'show' : 'hide');
 
+        this.$headingStyle.val(options.headingStyle);
+
         this.$mainFontSize.val(options.mainFontSize);
         this.$treeFontSize.val(options.treeFontSize);
         this.$detailFontSize.val(options.detailFontSize);

src/public/app/dialogs/sort_child_notes.js

@@ -0,0 +1,24 @@
+import server from "../services/server.js";
+import utils from "../services/utils.js";
+
+const $dialog = $("#sort-child-notes-dialog");
+const $form = $("#sort-child-notes-form");
+
+let parentNoteId = null;
+
+$form.on('submit', async () => {
+    const sortBy = $form.find("input[name='sort-by']:checked").val();
+    const sortDirection = $form.find("input[name='sort-direction']:checked").val();
+
+    await server.put(`notes/${parentNoteId}/sort-children`, {sortBy, sortDirection});
+
+    utils.closeActiveDialog();
+});
+
+export async function showDialog(noteId) {
+    parentNoteId = noteId;
+
+    utils.openDialog($dialog);
+
+    $form.find('input:first').focus();
+}

src/public/app/entities/note_short.js

@@ -2,6 +2,7 @@ import server from '../services/server.js';
 import noteAttributeCache from "../services/note_attribute_cache.js";
 import ws from "../services/ws.js";
 import options from "../services/options.js";
+import treeCache from "../services/tree_cache.js";
 
 const LABEL = 'label';
 const RELATION = 'relation';
@@ -253,6 +254,72 @@ class NoteShort {
         return noteAttributeCache.attributes[this.noteId];
     }
 
+    getAllNotePaths(encounteredNoteIds = null) {
+        if (this.noteId === 'root') {
+            return [['root']];
+        }
+
+        if (!encounteredNoteIds) {
+            encounteredNoteIds = new Set();
+        }
+
+        encounteredNoteIds.add(this.noteId);
+
+        const parentNotes = this.getParentNotes();
+        let paths;
+
+        if (parentNotes.length === 1) { // optimization for the most common case
+            if (encounteredNoteIds.has(parentNotes[0].noteId)) {
+                return [];
+            }
+            else {
+                paths = parentNotes[0].getAllNotePaths(encounteredNoteIds);
+            }
+        }
+        else {
+            paths = [];
+
+            for (const parentNote of parentNotes) {
+                if (encounteredNoteIds.has(parentNote.noteId)) {
+                    continue;
+                }
+
+                const newSet = new Set(encounteredNoteIds);
+
+                paths.push(...parentNote.getAllNotePaths(newSet));
+            }
+        }
+
+        for (const path of paths) {
+            path.push(this.noteId);
+        }
+
+        return paths;
+    }
+
+    getSortedNotePaths(hoistedNotePath = 'root') {
+        const notePaths = this.getAllNotePaths().map(path => ({
+            notePath: path,
+            isInHoistedSubTree: path.includes(hoistedNotePath),
+            isArchived: path.find(noteId => treeCache.notes[noteId].hasLabel('archived')),
+            isSearch: path.find(noteId => treeCache.notes[noteId].type === 'search')
+        }));
+
+        notePaths.sort((a, b) => {
+            if (a.isInHoistedSubTree !== b.isInHoistedSubTree) {
+                return a.isInHoistedSubTree ? -1 : 1;
+            } else if (a.isSearch !== b.isSearch) {
+                return a.isSearch ? 1 : -1;
+            } else if (a.isArchived !== b.isArchived) {
+                return a.isArchived ? 1 : -1;
+            } else {
+                return a.notePath.length - b.notePath.length;
+            }
+        });
+
+        return notePaths;
+    }
+
     __filterAttrs(attributes, type, name) {
         if (!type && !name) {
             return attributes;
@@ -292,7 +359,7 @@ class NoteShort {
         const workspaceIconClass = this.getWorkspaceIconClass();
 
         if (iconClassLabels.length > 0) {
-            return iconClassLabels.map(l => l.value).join(' ');
+            return iconClassLabels[0].value;
         }
         else if (workspaceIconClass) {
             return workspaceIconClass;
@@ -542,7 +609,7 @@ class NoteShort {
             });
     }
 
-    hasAncestor(ancestorNote, visitedNoteIds) {
+    hasAncestor(ancestorNote, visitedNoteIds = null) {
         if (this.noteId === ancestorNote.noteId) {
             return true;
         }

src/public/app/layouts/mobile_layout.js

@@ -83,6 +83,9 @@ export default class MobileLayout {
                     .child(new NoteTitleWidget())
                     .child(new CloseDetailButtonWidget()))
                 .child(new NoteDetailWidget()
-                    .css('padding', '5px 20px 10px 0')));
+                    .css('padding', '5px 20px 10px 0')
+                    .css('overflow', 'auto')
+                    .css('height', '100%')
+                ));
     }
 }

src/public/app/services/app_context.js

@@ -12,6 +12,7 @@ import keyboardActionsService from "./keyboard_actions.js";
 import MobileScreenSwitcherExecutor from "../widgets/mobile_widgets/mobile_screen_switcher.js";
 import MainTreeExecutors from "./main_tree_executors.js";
 import protectedSessionHolder from "./protected_session_holder.js";
+import toast from "./toast.js";
 
 class AppContext extends Component {
     constructor(isMainWindow) {
@@ -19,6 +20,7 @@ class AppContext extends Component {
 
         this.isMainWindow = isMainWindow;
         this.executors = [];
+        this.beforeUnloadListeners = [];
     }
 
     setLayout(layout) {
@@ -104,6 +106,15 @@ class AppContext extends Component {
     getComponentByEl(el) {
         return $(el).closest(".component").prop('component');
     }
+
+    addBeforeUnloadListener(obj) {
+        if (typeof WeakRef !== "function") {
+            // older browsers don't support WeakRef
+            return;
+        }
+
+        this.beforeUnloadListeners.push(new WeakRef(obj));
+    }
 }
 
 const appContext = new AppContext(window.glob.isMainWindow);
@@ -112,7 +123,29 @@ const appContext = new AppContext(window.glob.isMainWindow);
 $(window).on('beforeunload', () => {
     protectedSessionHolder.resetSessionCookie();
 
-    appContext.triggerEvent('beforeUnload');
+    let allSaved = true;
+
+    appContext.beforeUnloadListeners = appContext.beforeUnloadListeners.filter(wr => !!wr.deref());
+
+    for (const weakRef of appContext.beforeUnloadListeners) {
+        const component = weakRef.deref();
+
+        if (!component) {
+            continue;
+        }
+
+        if (!component.beforeUnloadEvent()) {
+            console.log(`Component ${component.componentId} is not finished saving its state.`);
+
+            toast.showMessage("Please wait for a couple of seconds for the save to finish, then you can try again.", 10000);
+
+            allSaved = false;
+        }
+    }
+
+    if (!allSaved) {
+        return "some string";
+    }
 });
 
 function isNotePathInAddress() {

src/public/app/services/attribute_renderer.js

@@ -79,6 +79,15 @@ async function renderAttributes(attributes, renderIsInheritable) {
     return $container;
 }
 
+const HIDDEN_ATTRIBUTES = [
+    'originalFileName',
+    'template',
+    'cssClass',
+    'iconClass',
+    'pageSize',
+    'viewType'
+];
+
 async function renderNormalAttributes(note) {
     const promotedDefinitionAttributes = note.getPromotedDefinitionAttributes();
     let attrs = note.getAttributes();
@@ -90,6 +99,7 @@ async function renderNormalAttributes(note) {
         attrs = attrs.filter(
             attr => !attr.isDefinition()
                  && !attr.isAutoLink
+                 && !HIDDEN_ATTRIBUTES.includes(attr.name)
                  && attr.noteId === note.noteId
         );
     }

src/public/app/services/branches.js

@@ -125,7 +125,7 @@ async function deleteNotes(branchIdsToDelete) {
 }
 
 async function moveNodeUpInHierarchy(node) {
-    if (hoistedNoteService.isRootNode(node)
+    if (hoistedNoteService.isHoistedNode(node)
         || hoistedNoteService.isTopLevelNode(node)
         || node.getParent().data.noteType === 'search') {
         return;

src/public/app/services/entrypoints.js

@@ -74,7 +74,11 @@ export default class Entrypoints extends Component {
 
         await ws.waitForMaxKnownEntityChangeId();
 
-        await appContext.tabManager.openTabWithNote(note.noteId, true);
+        const hoistedNoteId = appContext.tabManager.getActiveTabContext()
+            ? appContext.tabManager.getActiveTabContext().hoistedNoteId
+            : 'root';
+
+        await appContext.tabManager.openTabWithNote(note.noteId, true, null, hoistedNoteId);
 
         appContext.triggerEvent('focusAndSelectTitle');
     }
@@ -182,8 +186,6 @@ export default class Entrypoints extends Component {
         utils.reloadApp();
     }
 
-    createTopLevelNoteCommand() { noteCreateService.createNewTopLevelNote(); }
-
     async openInWindowCommand({notePath, hoistedNoteId}) {
         if (!hoistedNoteId) {
             hoistedNoteId = 'root';

src/public/app/services/hoisted_note.js

@@ -16,19 +16,17 @@ async function unhoist() {
 }
 
 function isTopLevelNode(node) {
-    return isRootNode(node.getParent());
+    return isHoistedNode(node.getParent());
 }
 
-function isRootNode(node) {
+function isHoistedNode(node) {
     // even though check for 'root' should not be necessary, we keep it just in case
     return node.data.noteId === "root"
         || node.data.noteId === getHoistedNoteId();
 }
 
 async function checkNoteAccess(notePath, tabContext) {
-    // notePath argument can contain only noteId which is not good when hoisted since
+    const resolvedNotePath = await treeService.resolveNotePath(notePath, tabContext.hoistedNoteId);
-    // then we need to check the whole note path
-    const resolvedNotePath = await treeService.resolveNotePath(notePath);
 
     if (!resolvedNotePath) {
         console.log("Cannot activate " + notePath);
@@ -37,7 +35,7 @@ async function checkNoteAccess(notePath, tabContext) {
 
     const hoistedNoteId = tabContext.hoistedNoteId;
 
-    if (hoistedNoteId !== 'root' && !resolvedNotePath.includes(hoistedNoteId)) {
+    if (!resolvedNotePath.includes(hoistedNoteId)) {
         const confirmDialog = await import('../dialogs/confirm.js');
 
         if (!await confirmDialog.confirm("Requested note is outside of hoisted note subtree and you must unhoist to access the note. Do you want to proceed with unhoisting?")) {
@@ -55,6 +53,6 @@ export default {
     getHoistedNoteId,
     unhoist,
     isTopLevelNode,
-    isRootNode,
+    isHoistedNode,
     checkNoteAccess
 }

src/public/app/services/link_map.js

@@ -117,7 +117,8 @@ export default class LinkMap {
 
             const $noteBox = $("<div>")
                 .addClass("note-box")
-                .prop("id", noteBoxId);
+                .prop("id", noteBoxId)
+                .addClass(note.getCssClass());
 
             const $link = $linkTitles[noteId];
 

src/public/app/services/main_tree_executors.js

@@ -27,28 +27,28 @@ export default class MainTreeExecutors extends Component {
     }
 
     async createNoteIntoCommand() {
-        const activeNote = appContext.tabManager.getActiveTabNote();
+        const activeTabContext = appContext.tabManager.getActiveTabContext();
 
-        if (!activeNote) {
+        if (!activeTabContext) {
             return;
         }
 
-        await noteCreateService.createNote(activeNote.noteId, {
+        await noteCreateService.createNote(activeTabContext.notePath, {
-            isProtected: activeNote.isProtected,
+            isProtected: activeTabContext.note.isProtected,
             saveSelection: false
         });
     }
 
     async createNoteAfterCommand() {
         const node = this.tree.getActiveNode();
-        const parentNoteId = node.data.parentNoteId;
+        const parentNotePath = treeService.getNotePath(node.getParent());
         const isProtected = await treeService.getParentProtectedStatus(node);
 
         if (node.data.noteId === 'root' || node.data.noteId === hoistedNoteService.getHoistedNoteId()) {
             return;
         }
 
-        await noteCreateService.createNote(parentNoteId, {
+        await noteCreateService.createNote(parentNotePath, {
             target: 'after',
             targetBranchId: node.data.branchId,
             isProtected: isProtected,

src/public/app/services/note_create.js

@@ -1,19 +1,13 @@
-import hoistedNoteService from "./hoisted_note.js";
 import appContext from "./app_context.js";
 import utils from "./utils.js";
 import protectedSessionHolder from "./protected_session_holder.js";
 import server from "./server.js";
 import ws from "./ws.js";
 import treeCache from "./tree_cache.js";
+import treeService from "./tree.js";
 import toastService from "./toast.js";
 
-async function createNewTopLevelNote() {
+async function createNote(parentNotePath, options = {}) {
-    const hoistedNoteId = hoistedNoteService.getHoistedNoteId();
-
-    await createNote(hoistedNoteId);
-}
-
-async function createNote(parentNoteId, options = {}) {
     options = Object.assign({
         activate: true,
         focus: 'title',
@@ -36,6 +30,8 @@ async function createNote(parentNoteId, options = {}) {
 
     const newNoteName = options.title || "new note";
 
+    const parentNoteId = treeService.getNoteIdFromNotePath(parentNotePath);
+
     const {note, branch} = await server.post(`notes/${parentNoteId}/children?target=${options.target}&targetBranchId=${options.targetBranchId}`, {
         title: newNoteName,
         content: options.content || "",
@@ -53,7 +49,7 @@ async function createNote(parentNoteId, options = {}) {
 
     if (options.activate) {
         const activeTabContext = appContext.tabManager.getActiveTabContext();
-        await activeTabContext.setNote(note.noteId);
+        await activeTabContext.setNote(`${parentNotePath}/${note.noteId}`);
 
         if (options.focus === 'title') {
             appContext.triggerEvent('focusAndSelectTitle');
@@ -88,12 +84,13 @@ function parseSelectedHtml(selectedHtml) {
     }
 }
 
-async function duplicateSubtree(noteId, parentNoteId) {
+async function duplicateSubtree(noteId, parentNotePath) {
+    const parentNoteId = treeService.getNoteIdFromNotePath(parentNotePath);
     const {note} = await server.post(`notes/${noteId}/duplicate/${parentNoteId}`);
 
     await ws.waitForMaxKnownEntityChangeId();
 
-    await appContext.tabManager.activateOrOpenNote(note.noteId);
+    await appContext.tabManager.activateOrOpenNote(`${parentNotePath}/${note.noteId}`);
 
     const origNote = await treeCache.getNote(noteId);
     toastService.showMessage(`Note "${origNote.title}" has been duplicated`);
@@ -101,6 +98,5 @@ async function duplicateSubtree(noteId, parentNoteId) {
 
 export default {
     createNote,
-    createNewTopLevelNote,
     duplicateSubtree
 };

src/public/app/services/protected_session_holder.js

@@ -1,5 +1,6 @@
 import utils from "./utils.js";
 import options from './options.js';
+import server from "./server.js";
 
 const PROTECTED_SESSION_ID_KEY = 'protectedSessionId';
 
@@ -23,11 +24,11 @@ function resetSessionCookie() {
     utils.setSessionCookie(PROTECTED_SESSION_ID_KEY, null);
 }
 
-function resetProtectedSession() {
+async function resetProtectedSession() {
     resetSessionCookie();
 
-    // most secure solution - guarantees nothing remained in memory
+    await server.post("logout/protected");
-    // since this expires because user doesn't use the app, it shouldn't be disruptive
+
     utils.reloadApp();
 }
 

src/public/app/services/spaced_update.js

@@ -15,9 +15,25 @@ export default class SpacedUpdate {
 
     async updateNowIfNecessary() {
         if (this.changed) {
-            this.changed = false;
+            this.changed = false; // optimistic...
+
+            try {
                 await this.updater();
             }
+            catch (e) {
+                this.changed = true;
+
+                throw e;
+            }
+        }
+    }
+
+    isAllSavedAndTriggerUpdate() {
+        const allSaved = !this.changed;
+
+        this.updateNowIfNecessary();
+
+        return allSaved;
     }
 
     triggerUpdate() {

src/public/app/services/tab_context.js

@@ -79,7 +79,7 @@ class TabContext extends Component {
             return inputNotePath;
         }
 
-        const resolvedNotePath = await treeService.resolveNotePath(inputNotePath);
+        const resolvedNotePath = await treeService.resolveNotePath(inputNotePath, this.hoistedNoteId);
 
         if (!resolvedNotePath) {
             logError(`Cannot resolve note path ${inputNotePath}`);

src/public/app/services/tab_manager.js

@@ -27,6 +27,8 @@ export default class TabManager extends Component {
                 openTabs: JSON.stringify(openTabs)
             });
         });
+
+        appContext.addBeforeUnloadListener(this);
     }
 
     /** @type {TabContext[]} */
@@ -203,7 +205,7 @@ export default class TabManager extends Component {
         let hoistedNoteId = 'root';
 
         if (tabContext) {
-            const resolvedNotePath = await treeService.resolveNotePath(notePath);
+            const resolvedNotePath = await treeService.resolveNotePath(notePath, tabContext.hoistedNoteId);
 
             if (resolvedNotePath.includes(tabContext.hoistedNoteId)) {
                 hoistedNoteId = tabContext.hoistedNoteId;
@@ -329,6 +331,8 @@ export default class TabManager extends Component {
 
     beforeUnloadEvent() {
         this.tabsUpdate.updateNowIfNecessary();
+
+        return true; // don't block closing the tab, this metadata is not that important
     }
 
     openNewTabCommand() {

src/public/app/services/tree.js

@@ -8,8 +8,8 @@ import appContext from "./app_context.js";
 /**
  * @return {string|null}
  */
-async function resolveNotePath(notePath) {
+async function resolveNotePath(notePath, hoistedNoteId = 'root') {
-    const runPath = await resolveNotePathToSegments(notePath);
+    const runPath = await resolveNotePathToSegments(notePath, hoistedNoteId);
 
     return runPath ? runPath.join("/") : null;
 }
@@ -21,7 +21,7 @@ async function resolveNotePath(notePath) {
  *
  * @return {string[]}
  */
-async function resolveNotePathToSegments(notePath, logErrors = true) {
+async function resolveNotePathToSegments(notePath, hoistedNoteId = 'root', logErrors = true) {
     utils.assertArguments(notePath);
 
     // we might get notePath with the tabId suffix, remove it if present
@@ -37,7 +37,7 @@ async function resolveNotePathToSegments(notePath, logErrors = true) {
         path.push('root');
     }
 
-    const effectivePath = [];
+    const effectivePathSegments = [];
     let childNoteId = null;
     let i = 0;
 
@@ -75,13 +75,13 @@ async function resolveNotePathToSegments(notePath, logErrors = true) {
                     console.log(utils.now(), `Did not find parent ${parentNoteId} (${parent ? parent.title : 'n/a'}) for child ${childNoteId} (${child.title}), available parents: ${parents.map(p => `${p.noteId} (${p.title})`)}`);
                 }
 
-                const someNotePath = getSomeNotePath(parents[0]);
+                const someNotePath = getSomeNotePath(child, hoistedNoteId);
 
                 if (someNotePath) { // in case it's root the path may be empty
-                    const pathToRoot = someNotePath.split("/").reverse();
+                    const pathToRoot = someNotePath.split("/").reverse().slice(1);
 
                     for (const noteId of pathToRoot) {
-                        effectivePath.push(noteId);
+                        effectivePathSegments.push(noteId);
                     }
                 }
 
@@ -89,36 +89,37 @@ async function resolveNotePathToSegments(notePath, logErrors = true) {
             }
         }
 
-        effectivePath.push(parentNoteId);
+        effectivePathSegments.push(parentNoteId);
         childNoteId = parentNoteId;
     }
 
-    return effectivePath.reverse();
+    effectivePathSegments.reverse();
+
+    if (effectivePathSegments.includes(hoistedNoteId)) {
+        return effectivePathSegments;
+    }
+    else {
+        const note = await treeCache.getNote(getNoteIdFromNotePath(notePath));
+
+        const someNotePathSegments = getSomeNotePathSegments(note, hoistedNoteId);
+
+        // if there isn't actually any note path with hoisted note then return the original resolved note path
+        return someNotePathSegments.includes(hoistedNoteId) ? someNotePathSegments : effectivePathSegments;
+    }
 }
 
-function getSomeNotePath(note) {
+function getSomeNotePathSegments(note, hoistedNotePath = 'root') {
     utils.assertArguments(note);
 
-    const path = [];
+    const notePaths = note.getSortedNotePaths(hoistedNotePath);
 
-    let cur = note;
+    return notePaths[0].notePath;
+}
 
-    while (cur.noteId !== 'root') {
+function getSomeNotePath(note, hoistedNotePath = 'root') {
-        path.push(cur.noteId);
+    const notePath = getSomeNotePathSegments(note, hoistedNotePath);
 
-        const parents = cur.getParentNotes().filter(note => note.type !== 'search');
+    return notePath.join('/');
-
-        if (!parents.length) {
-            logError(`Can't find parents for note ${cur.noteId}`);
-            return;
-        }
-
-        cur = parents[0];
-    }
-
-    path.push('root');
-
-    return path.reverse().join('/');
 }
 
 async function sortAlphabetically(noteId) {
@@ -138,7 +139,7 @@ ws.subscribeToMessages(message => {
 });
 
 function getParentProtectedStatus(node) {
-    return hoistedNoteService.isRootNode(node) ? 0 : node.getParent().data.isProtected;
+    return hoistedNoteService.isHoistedNode(node) ? 0 : node.getParent().data.isProtected;
 }
 
 function getNoteIdFromNotePath(notePath) {
@@ -198,7 +199,7 @@ function getNotePath(node) {
 
     const path = [];
 
-    while (node && !hoistedNoteService.isRootNode(node)) {
+    while (node) {
         if (node.data.noteId) {
             path.push(node.data.noteId);
         }
@@ -206,10 +207,6 @@ function getNotePath(node) {
         node = node.getParent();
     }
 
-    if (node) { // null node can happen directly after unhoisting when tree is still hoisted but option has been changed already
-        path.push(node.data.noteId); // root or hoisted noteId
-    }
-
     return path.reverse().join("/");
 }
 
@@ -313,6 +310,7 @@ export default {
     resolveNotePath,
     resolveNotePathToSegments,
     getSomeNotePath,
+    getSomeNotePathSegments,
     getParentProtectedStatus,
     getNotePath,
     getNoteIdFromNotePath,

src/public/app/services/tree_context_menu.js

@@ -75,7 +75,7 @@ class TreeContextMenu {
                     { title: 'Expand subtree <kbd data-command="expandSubtree"></kbd>', command: "expandSubtree", uiIcon: "expand", enabled: noSelectedNotes },
                     { title: 'Collapse subtree <kbd data-command="collapseSubtree"></kbd>', command: "collapseSubtree", uiIcon: "collapse", enabled: noSelectedNotes },
                     { title: "Force note sync", command: "forceNoteSync", uiIcon: "refresh", enabled: noSelectedNotes },
-                    { title: 'Sort alphabetically <kbd data-command="sortChildNotes"></kbd>', command: "sortChildNotes", uiIcon: "empty", enabled: noSelectedNotes && notSearch },
+                    { title: 'Sort by ... <kbd data-command="sortChildNotes"></kbd>', command: "sortChildNotes", uiIcon: "empty", enabled: noSelectedNotes && notSearch },
                     { title: 'Recent changes in subtree', command: "recentChangesInSubtree", uiIcon: "history", enabled: noSelectedNotes }
                 ] },
             { title: "----" },
@@ -112,10 +112,10 @@ class TreeContextMenu {
             appContext.tabManager.openTabWithNoteWithHoisting(notePath);
         }
         else if (command === "insertNoteAfter") {
-            const parentNoteId = this.node.data.parentNoteId;
+            const parentNotePath = treeService.getNotePath(this.node.getParent());
             const isProtected = await treeService.getParentProtectedStatus(this.node);
 
-            noteCreateService.createNote(parentNoteId, {
+            noteCreateService.createNote(parentNotePath, {
                 target: 'after',
                 targetBranchId: this.node.data.branchId,
                 type: type,
@@ -123,14 +123,14 @@ class TreeContextMenu {
             });
         }
         else if (command === "insertChildNote") {
-            noteCreateService.createNote(noteId, {
+            const parentNotePath = treeService.getNotePath(this.node);
+
+            noteCreateService.createNote(parentNotePath, {
                 type: type,
                 isProtected: this.node.data.isProtected
             });
         }
         else {
-            console.log("Triggering", command, notePath);
-
             this.treeWidget.triggerCommand(command, {node: this.node, notePath: notePath});
         }
     }

src/public/app/widgets/attribute_widgets/attribute_detail.js

@@ -194,9 +194,18 @@ const ATTR_HELP = {
         "appTheme": "marks CSS notes which are full Trilium themes and are thus available in Trilium options.",
         "cssClass": "value of this label is then added as CSS class to the node representing given note in the tree. This can be useful for advanced theming. Can be used in template notes.",
         "iconClass": "value of this label is added as a CSS class to the icon on the tree which can help visually distinguish the notes in the tree. Example might be bx bx-home - icons are taken from boxicons. Can be used in template notes.",
-        "bookZoomLevel": 'applies only to book note and sets the "zoom level" (how many notes fit on 1 row)',
+        "pageSize": "number of items per page in note listing",
         "customRequestHandler": 'see <a href="javascript:" data-help-page="Custom request handler">Custom request handler</a>',
-        "customResourceProvider": 'see <a href="javascript:" data-help-page="Custom request handler">Custom request handler</a>'
+        "customResourceProvider": 'see <a href="javascript:" data-help-page="Custom request handler">Custom request handler</a>',
+        "widget": "marks this note as a custom widget which will be added to the Trilium component tree",
+        "workspace": "marks this note as a workspace which allows easy hoisting",
+        "workspaceIconClass": "defines box icon CSS class which will be used in tab when hoisted to this note",
+        "workspaceTabBackgroundColor": "CSS color used in the note tab when hoisted to this note",
+        "searchHome": "new search notes will be created as children of this note",
+        "hoistedSearchHome": "new search notes will be created as children of this note when hoisted to some ancestor of this note",
+        "inbox": "default inbox location for new notes",
+        "hoistedInbox": "default inbox location for new notes when hoisted to some ancestor of this note",
+        "sqlConsoleHome": "default location of SQL console notes",
     },
     "relation": {
         "runOnNoteCreation": "executes when note is created on backend",

src/public/app/widgets/attribute_widgets/attribute_editor.js

@@ -491,7 +491,7 @@ export default class AttributeEditorWidget extends TabAwareWidget {
     }
 
     async createNoteForReferenceLink(title) {
-        const {note} = await noteCreateService.createNote(this.noteId, {
+        const {note} = await noteCreateService.createNote(this.notePath, {
             activate: false,
             title: title
         });

src/public/app/widgets/mobile_widgets/mobile_detail_menu.js

@@ -26,7 +26,7 @@ class MobileDetailMenuWidget extends BasicWidget {
                 ],
                 selectMenuItemHandler: async ({command}) => {
                     if (command === "insertChildNote") {
-                        noteCreateService.createNote(note.noteId);
+                        noteCreateService.createNote(appContext.tabManager.getActiveTabNotePath());
                     }
                     else if (command === "delete") {
                         const notePath = appContext.tabManager.getActiveTabNotePath();

src/public/app/widgets/mobile_widgets/mobile_global_buttons.js

@@ -13,7 +13,7 @@ const WIDGET_TPL = `
     }
     </style>
 
-    <a data-trigger-command="createTopLevelNote" title="Create new top level note" class="icon-action bx bx-folder-plus"></a>
+    <a data-trigger-command="createNoteIntoInbox" title="New note" class="icon-action bx bx-folder-plus"></a>
 
     <a data-trigger-command="collapseTree" title="Collapse note tree" class="icon-action bx bx-layer-minus"></a>
 

src/public/app/widgets/note_detail.js

@@ -65,6 +65,8 @@ export default class NoteDetailWidget extends TabAwareWidget {
 
             await server.put('notes/' + noteId, dto, this.componentId);
         });
+
+        appContext.addBeforeUnloadListener(this);
     }
 
     isEnabled() {
@@ -276,7 +278,7 @@ export default class NoteDetailWidget extends TabAwareWidget {
 
             const label = attrs.find(attr =>
                 attr.type === 'label'
-                && ['readOnly', 'autoReadOnlyDisabled', 'cssClass', 'bookZoomLevel', 'displayRelations'].includes(attr.name)
+                && ['readOnly', 'autoReadOnlyDisabled', 'cssClass', 'displayRelations'].includes(attr.name)
                 && attr.isAffecting(this.note));
 
             const relation = attrs.find(attr =>
@@ -293,7 +295,7 @@ export default class NoteDetailWidget extends TabAwareWidget {
     }
 
     beforeUnloadEvent() {
-        this.spacedUpdate.updateNowIfNecessary();
+        return this.spacedUpdate.isAllSavedAndTriggerUpdate();
     }
 
     textPreviewDisabledEvent({tabContext}) {
@@ -316,7 +318,7 @@ export default class NoteDetailWidget extends TabAwareWidget {
         }
 
         // without await as this otherwise causes deadlock through component mutex
-        noteCreateService.createNote(note.noteId, {
+        noteCreateService.createNote(appContext.tabManager.getActiveTabNotePath(), {
             isProtected: note.isProtected,
             saveSelection: true
         });

src/public/app/widgets/note_icon.js

@@ -16,6 +16,7 @@ const TPL = `
         border: 1px solid transparent;
         cursor: pointer;
         padding: 6px;
+        color: var(--main-text-color);
     }
     
     .note-icon-container button.note-icon:hover {

src/public/app/widgets/note_paths.js

@@ -15,9 +15,21 @@ const TPL = `
     }
     
     .note-path-list {
-        max-height: 600px;
+        max-height: 700px;
         overflow-y: auto;
     }
+    
+    .note-path-list .path-current {
+        font-weight: bold;
+    }
+    
+    .note-path-list .path-archived {
+        color: var(--muted-text-color) !important;
+    }
+    
+    .note-path-list .path-search {
+        font-style: italic;
+    }
     </style>
     
     <button class="btn dropdown-toggle note-path-list-button bx bx-collection" type="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false" title="Note paths"></button>
@@ -43,20 +55,12 @@ export default class NotePathsWidget extends TabAwareWidget {
         );
 
         if (this.noteId === 'root') {
-            await this.addPath('root', true);
+            await this.addPath('root');
             return;
         }
 
-        const pathSegments = treeService.parseNotePath(this.notePath);
+        for (const notePathRecord of this.note.getSortedNotePaths(this.hoistedNoteId)) {
-        const activeNoteParentNoteId = pathSegments[pathSegments.length - 2]; // we know this is not root so there must be a parent
+            await this.addPath(notePathRecord);
-
-        for (const parentNote of this.note.getParentNotes()) {
-            const parentNotePath = treeService.getSomeNotePath(parentNote);
-            // this is to avoid having root notes leading '/'
-            const notePath = parentNotePath ? (parentNotePath + '/' + this.noteId) : this.noteId;
-            const isCurrent = activeNoteParentNoteId === parentNote.noteId;
-
-            await this.addPath(notePath, isCurrent);
         }
 
         const cloneLink = $("<div>")
@@ -70,7 +74,9 @@ export default class NotePathsWidget extends TabAwareWidget {
         this.$notePathList.append(cloneLink);
     }
 
-    async addPath(notePath, isCurrent) {
+    async addPath(notePathRecord) {
+        const notePath = notePathRecord.notePath.join('/');
+
         const title = await treeService.getNotePathTitle(notePath);
 
         const $noteLink = await linkService.createNoteLink(notePath, {title});
@@ -82,8 +88,33 @@ export default class NotePathsWidget extends TabAwareWidget {
             .find('a')
             .addClass("no-tooltip-preview");
 
-        if (isCurrent) {
+        const icons = [];
-            $noteLink.addClass("current");
+
+        if (this.notePath === notePath) {
+            $noteLink.addClass("path-current");
+        }
+
+        if (notePathRecord.isInHoistedSubTree) {
+            $noteLink.addClass("path-in-hoisted-subtree");
+        }
+        else {
+            icons.push(`<span class="bx bx-trending-up" title="This path is outside of hoisted note and you would have to unhoist."></span>`);
+        }
+
+        if (notePathRecord.isArchived) {
+            $noteLink.addClass("path-archived");
+
+            icons.push(`<span class="bx bx-archive" title="Archived"></span>`);
+        }
+
+        if (notePathRecord.isSearch) {
+            $noteLink.addClass("path-search");
+
+            icons.push(`<span class="bx bx-search" title="Search"></span>`);
+        }
+
+        if (icons.length > 0) {
+            $noteLink.append(` ${icons.join(' ')}`);
         }
 
         this.$notePathList.append($noteLink);
@@ -96,4 +127,10 @@ export default class NotePathsWidget extends TabAwareWidget {
             this.refresh();
         }
     }
+
+    async refresh() {
+        await super.refresh();
+
+        this.$widget.find('.dropdown-toggle').dropdown('hide');
+    }
 }

src/public/app/widgets/note_title.js

@@ -3,6 +3,7 @@ import utils from "../services/utils.js";
 import protectedSessionHolder from "../services/protected_session_holder.js";
 import server from "../services/server.js";
 import SpacedUpdate from "../services/spaced_update.js";
+import appContext from "../services/app_context.js";
 
 const TPL = `
 <div class="note-title-container">
@@ -35,8 +36,10 @@ export default class NoteTitleWidget extends TabAwareWidget {
 
             protectedSessionHolder.touchProtectedSessionIfNecessary(this.note);
 
-            await server.put(`notes/${this.noteId}/change-title`, {title});
+            await server.put(`notes/${this.noteId}/change-title`, {title}, this.componentId);
         });
+
+        appContext.addBeforeUnloadListener(this);
     }
 
     doRender() {
@@ -101,6 +104,6 @@ export default class NoteTitleWidget extends TabAwareWidget {
     }
 
     beforeUnloadEvent() {
-        this.spacedUpdate.updateNowIfNecessary();
+        return this.spacedUpdate.isAllSavedAndTriggerUpdate();
     }
 }

src/public/app/widgets/note_tree.js

@@ -176,6 +176,15 @@ const TPL = `
                       title="Images which are shown in the parent text note will not be displayed in the tree"></span>
             </label>
         </div>
+        <div class="form-check">
+            <label class="form-check-label">
+                <input class="form-check-input auto-collapse-note-tree" type="checkbox" value="">
+                
+                Automatically collapse notes
+                <span class="bx bx-info-circle" 
+                      title="Notes will be collapsed after period of inactivity to declutter the tree."></span>
+            </label>
+        </div>
     
         <br/>
     
@@ -203,8 +212,9 @@ export default class NoteTreeWidget extends TabAwareWidget {
         this.$tree.on("mousedown", ".refresh-search-button", e => this.refreshSearch(e));
         this.$tree.on("mousedown", ".add-note-button", e => {
             const node = $.ui.fancytree.getNode(e);
+            const parentNotePath = treeService.getNotePath(node);
 
-            noteCreateService.createNote(node.data.noteId, {
+            noteCreateService.createNote(parentNotePath, {
                 isProtected: node.data.isProtected
             });
         });
@@ -234,6 +244,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
         this.$treeSettingsPopup = this.$widget.find('.tree-settings-popup');
         this.$hideArchivedNotesCheckbox = this.$treeSettingsPopup.find('.hide-archived-notes');
         this.$hideIncludedImages = this.$treeSettingsPopup.find('.hide-included-images');
+        this.$autoCollapseNoteTree = this.$treeSettingsPopup.find('.auto-collapse-note-tree');
 
         this.$treeSettingsButton = this.$widget.find('.tree-settings-button');
         this.$treeSettingsButton.on("click", e => {
@@ -244,6 +255,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
 
             this.$hideArchivedNotesCheckbox.prop("checked", this.hideArchivedNotes);
             this.$hideIncludedImages.prop("checked", this.hideIncludedImages);
+            this.$autoCollapseNoteTree.prop("checked", this.autoCollapseNoteTree);
 
             let top = this.$treeSettingsButton[0].offsetTop;
             let left = this.$treeSettingsButton[0].offsetLeft;
@@ -271,6 +283,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
         this.$saveTreeSettingsButton.on('click', async () => {
             await this.setHideArchivedNotes(this.$hideArchivedNotesCheckbox.prop("checked"));
             await this.setHideIncludedImages(this.$hideIncludedImages.prop("checked"));
+            await this.setAutoCollapseNoteTree(this.$autoCollapseNoteTree.prop("checked"));
 
             this.$treeSettingsPopup.hide();
 
@@ -326,6 +339,14 @@ export default class NoteTreeWidget extends TabAwareWidget {
         await options.save("hideIncludedImages_" + this.treeName, val.toString());
     }
 
+    get autoCollapseNoteTree() {
+        return options.is("autoCollapseNoteTree");
+    }
+
+    async setAutoCollapseNoteTree(val) {
+        await options.save("autoCollapseNoteTree", val.toString());
+    }
+
     initFancyTree() {
         const treeData = [this.prepareRootNode()];
 
@@ -361,8 +382,6 @@ export default class NoteTreeWidget extends TabAwareWidget {
                     }
                     else {
                         node.setActive();
-
-                        this.clearSelectedNodes();
                     }
 
                     return false;
@@ -372,6 +391,8 @@ export default class NoteTreeWidget extends TabAwareWidget {
                 // click event won't propagate so let's close context menu manually
                 contextMenu.hide();
 
+                this.clearSelectedNodes();
+
                 const notePath = treeService.getNotePath(data.node);
 
                 const activeTabContext = appContext.tabManager.getActiveTabContext();
@@ -594,7 +615,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
 
         let childBranches = parentNote.getFilteredChildBranches();
 
-        if (childBranches.length > MAX_SEARCH_RESULTS_IN_TREE) {
+        if (parentNote.type === 'search' && childBranches.length > MAX_SEARCH_RESULTS_IN_TREE) {
             childBranches = childBranches.slice(0, MAX_SEARCH_RESULTS_IN_TREE);
         }
 
@@ -796,20 +817,20 @@ export default class NoteTreeWidget extends TabAwareWidget {
 
             const node = await this.expandToNote(activeContext.notePath);
 
+            if (node) {
                 await node.makeVisible({scrollIntoView: true});
                 node.setActive(true, {noEvents: true, noFocus: false});
             }
         }
+    }
 
     /** @return {FancytreeNode} */
     async getNodeFromPath(notePath, expand = false, logErrors = true) {
         utils.assertArguments(notePath);
+        /** @let {FancytreeNode} */
+        let parentNode = this.getNodesByNoteId('root')[0];
 
-        const hoistedNoteId = hoistedNoteService.getHoistedNoteId();
+        let resolvedNotePathSegments = await treeService.resolveNotePathToSegments(notePath, this.hoistedNoteId, logErrors);
-        /** @const {FancytreeNode} */
-        let parentNode = null;
-
-        const resolvedNotePathSegments = await treeService.resolveNotePathToSegments(notePath, logErrors);
 
         if (!resolvedNotePathSegments) {
             if (logErrors) {
@@ -819,14 +840,9 @@ export default class NoteTreeWidget extends TabAwareWidget {
             return;
         }
 
+        resolvedNotePathSegments = resolvedNotePathSegments.slice(1);
+
         for (const childNoteId of resolvedNotePathSegments) {
-            if (childNoteId === hoistedNoteId) {
-                // there must be exactly one node with given hoistedNoteId
-                parentNode = this.getNodesByNoteId(childNoteId)[0];
-
-                continue;
-            }
-
             // we expand only after hoisted note since before then nodes are not actually present in the tree
             if (parentNode) {
                 if (!parentNode.isLoaded()) {
@@ -857,7 +873,11 @@ export default class NoteTreeWidget extends TabAwareWidget {
                             // these are real notes with real notePath, user can display them in a detail
                             // but they don't have a node in the tree
 
-                            ws.logError(`Can't find node for child node of noteId=${childNoteId} for parent of noteId=${parentNode.data.noteId} and hoistedNoteId=${hoistedNoteId}, requested path is ${notePath}`);
+                            const childNote = await treeCache.getNote(childNoteId);
+
+                            if (!childNote || childNote.type !== 'image') {
+                                ws.logError(`Can't find node for child node of noteId=${childNoteId} for parent of noteId=${parentNode.data.noteId} and hoistedNoteId=${hoistedNoteService.getHoistedNoteId()}, requested path is ${notePath}`);
+                            }
                         }
 
                         return;
@@ -961,6 +981,10 @@ export default class NoteTreeWidget extends TabAwareWidget {
         }
 
         this.autoCollapseTimeoutId = setTimeout(() => {
+            if (!this.autoCollapseNoteTree) {
+                return;
+            }
+
             /*
              * We're collapsing notes after period of inactivity to "cleanup" the tree - users rarely
              * collapse the notes and the tree becomes unusuably large.
@@ -999,6 +1023,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
         const activeNodeFocused = activeNode && activeNode.hasFocus();
         const nextNode = activeNode ? (activeNode.getNextSibling() || activeNode.getPrevSibling() || activeNode.getParent()) : null;
         const activeNotePath = activeNode ? treeService.getNotePath(activeNode) : null;
+
         const nextNotePath = nextNode ? treeService.getNotePath(nextNode) : null;
         const activeNoteId = activeNode ? activeNode.data.noteId : null;
 
@@ -1119,7 +1144,12 @@ export default class NoteTreeWidget extends TabAwareWidget {
             }
 
             if (node) {
-                node.setActive(true, {noEvents: true, noFocus: true});
+                if (activeNodeFocused) {
+                    // needed by Firefox: https://github.com/zadam/trilium/issues/1865
+                    this.tree.$container.focus();
+                }
+
+                await node.setActive(true, {noEvents: true, noFocus: !activeNodeFocused});
             }
             else {
                 // this is used when original note has been deleted and we want to move the focus to the note above/below
@@ -1131,15 +1161,15 @@ export default class NoteTreeWidget extends TabAwareWidget {
                     //        this should be done by tabcontext / tabmanager and note tree should only listen to
                     //        changes in active note and just set the "active" state
                     // We don't await since that can bring up infinite cycles when e.g. custom widget does some backend requests which wait for max sync ID processed
-                    appContext.tabManager.getActiveTabContext().setNote(nextNotePath);
+                    appContext.tabManager.getActiveTabContext().setNote(nextNotePath).then(() => {
-                }
-            }
-
                         const newActiveNode = this.getActiveNode();
 
                         // return focus if the previously active node was also focused
-            if (newActiveNode && activeNodeFocused) {
+                        if (newActiveNode && activeNodeFocused) {console.log("FOCUSING!!!");
-                await newActiveNode.setFocus(true);
+                            newActiveNode.setFocus(true);
+                        }
+                    });
+                }
             }
         }
 
@@ -1207,13 +1237,20 @@ export default class NoteTreeWidget extends TabAwareWidget {
         }
     }
 
-    filterHoistedBranch() {
+    async filterHoistedBranch() {
         if (this.tabContext) {
+            // make sure the hoisted node is loaded (can be unloaded e.g. after tree collapse in another tab)
+            const hoistedNotePath = await treeService.resolveNotePath(this.tabContext.hoistedNoteId);
+            await this.getNodeFromPath(hoistedNotePath);
+
             if (this.tabContext.hoistedNoteId === 'root') {
                 this.tree.clearFilter();
             }
             else {
-                this.tree.filterBranches(node => node.data.noteId === this.tabContext.hoistedNoteId);
+                // hack when hoisted note is cloned then it could be filtered multiple times while we want only 1
+                this.tree.filterBranches(node =>
+                    node.data.noteId === this.tabContext.hoistedNoteId // optimization to not having always resolve the node path
+                    && treeService.getNotePath(node) === hoistedNotePath);
             }
         }
     }
@@ -1370,7 +1407,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
     }
 
     sortChildNotesCommand({node}) {
-        treeService.sortAlphabetically(node.data.noteId);
+        import("../dialogs/sort_child_notes.js").then(d => d.showDialog(node.data.noteId));
     }
 
     async recentChangesInSubtreeCommand({node}) {

src/public/app/widgets/quick_search.js

@@ -49,7 +49,11 @@ export default class QuickSearchWidget extends BasicWidget {
         this.$widget.find('.input-group-append').on('shown.bs.dropdown', () => this.search());
 
         utils.bindElShortcut(this.$searchString, 'return', () => {
+            if (this.$dropdownMenu.is(":visible")) {
+                this.search(); // just update already visible dropdown
+            } else {
                 this.$dropdownToggle.dropdown('show');
+            }
 
             this.$searchString.focus();
         });

src/public/app/widgets/search_actions/delete_note.js

@@ -5,7 +5,7 @@ const TPL = `
     <td colspan="2">
         <span class="bx bx-trash"></span>
     
-        Delete matched note
+        Delete matched notes
     </td>
     <td class="button-column">
         <span class="bx bx-x icon-action action-conf-del"></span>

src/public/app/widgets/standard_top_widget.js

@@ -14,6 +14,10 @@ const TPL = `
         height: 35px;
     }
     
+    .standard-top-widget > div {
+        flex-shrink: 0; /* fixes https://github.com/zadam/trilium/issues/1745 */
+    }
+    
     .standard-top-widget button.noborder {
         padding: 1px 5px 1px 5px;
         font-size: 90%;

src/public/app/widgets/tab_aware_widget.js

@@ -22,6 +22,10 @@ export default class TabAwareWidget extends BasicWidget {
         return this.tabContext && this.tabContext.notePath;
     }
 
+    get hoistedNoteId() {
+        return this.tabContext && this.tabContext.hoistedNoteId;
+    }
+
     isEnabled() {
         return !!this.note;
     }

src/public/app/widgets/type_property_widgets/inherited_attribute_list.js

@@ -83,4 +83,10 @@ export default class InheritedAttributesWidget extends TabAwareWidget {
     getInheritedAttributes(note) {
         return note.getAttributes().filter(attr => attr.noteId !== this.noteId);
     }
+
+    entitiesReloadedEvent({loadResults}) {
+        if (loadResults.getAttributes(this.componentId).find(attr => attr.isAffecting(this.note))) {
+            this.refresh();
+        }
+    }
 }

src/public/app/widgets/type_widgets/abstract_text_type_widget.js

@@ -5,24 +5,47 @@ import linkService from "../../services/link.js";
 import noteContentRenderer from "../../services/note_content_renderer.js";
 
 export default class AbstractTextTypeWidget extends TypeWidget {
-    doRender() {
+    setupImageOpening(singleClickOpens) {
-        this.$widget.on("dblclick", "img", e => {
+        this.$widget.on("dblclick", "img", e => this.openImageInCurrentTab($(e.target)));
-            const $img = $(e.target);
-            const src = $img.prop("src");
 
-            const match = src.match(/\/api\/images\/([A-Za-z0-9]+)\//);
+        this.$widget.on("click", "img", e => {
-
+            if ((e.which === 1 && e.ctrlKey) || e.which === 2) {
-            if (match) {
+                this.openImageInNewTab($(e.target));
-                const noteId = match[1];
-
-                appContext.tabManager.getActiveTabContext().setNote(noteId);
             }
-            else {
+            else if (e.which === 1 && singleClickOpens) {
-                window.open(src, '_blank');
+                this.openImageInCurrentTab($(e.target));
             }
         });
     }
 
+    openImageInCurrentTab($img) {
+        const imgSrc = $img.prop("src");
+        const noteId = this.getNoteIdFromImage(imgSrc);
+
+        if (noteId) {
+            appContext.tabManager.getActiveTabContext().setNote(noteId);
+        } else {
+            window.open(imgSrc, '_blank');
+        }
+    }
+
+    openImageInNewTab($img) {
+        const imgSrc = $img.prop("src");
+        const noteId = this.getNoteIdFromImage(imgSrc);
+
+        if (noteId) {
+            appContext.tabManager.openTabWithNoteWithHoisting(noteId);
+        } else {
+            window.open(imgSrc, '_blank');
+        }
+    }
+
+    getNoteIdFromImage(imgSrc) {
+        const match = imgSrc.match(/\/api\/images\/([A-Za-z0-9]+)\//);
+
+        return match ? match[1] : null;
+    }
+
     async loadIncludedNote(noteId, $el) {
         const note = await treeCache.getNote(noteId);
 

src/public/app/widgets/type_widgets/editable_text.js

@@ -49,15 +49,16 @@ const TPL = `
     }
          
     .note-detail-editable-text h2 { font-size: 1.8em; } 
-    .note-detail-editable-text h2::before { content: "##\\2004"; color: var(--muted-text-color); }
     .note-detail-editable-text h3 { font-size: 1.6em; }
-    .note-detail-editable-text h3::before { content: "###\\2004"; color: var(--muted-text-color); }
     .note-detail-editable-text h4 { font-size: 1.4em; }
-    .note-detail-editable-text h4:not(.include-note-title)::before { content: "####\\2004"; color: var(--muted-text-color); }
     .note-detail-editable-text h5 { font-size: 1.2em; }
-    .note-detail-editable-text h5::before { content: "#####\\2004"; color: var(--muted-text-color); }
     .note-detail-editable-text h6 { font-size: 1.1em; }
-    .note-detail-editable-text h6::before { content: "######\\2004"; color: var(--muted-text-color); }
+    
+    body.heading-style-markdown .note-detail-editable-text h2::before { content: "##\\2004"; color: var(--muted-text-color); }
+    body.heading-style-markdown .note-detail-editable-text h3::before { content: "###\\2004"; color: var(--muted-text-color); }
+    body.heading-style-markdown .note-detail-editable-text h4:not(.include-note-title)::before { content: "####\\2004"; color: var(--muted-text-color); }
+    body.heading-style-markdown .note-detail-editable-text h5::before { content: "#####\\2004"; color: var(--muted-text-color); }
+    body.heading-style-markdown .note-detail-editable-text h6::before { content: "######\\2004"; color: var(--muted-text-color); }
     
     .note-detail-editable-text-editor {
         padding-top: 10px;
@@ -83,6 +84,8 @@ export default class EditableTextTypeWidget extends AbstractTextTypeWidget {
 
         keyboardActionService.setupActionsForElement('text-detail', this.$widget, this);
 
+        this.setupImageOpening(false);
+
         super.doRender();
     }
 
@@ -274,7 +277,7 @@ export default class EditableTextTypeWidget extends AbstractTextTypeWidget {
     }
 
     async createNoteForReferenceLink(title) {
-        const {note} = await noteCreateService.createNote(this.noteId, {
+        const {note} = await noteCreateService.createNote(this.notePath, {
             activate: false,
             title: title
         });

src/public/app/widgets/type_widgets/read_only_code.js

@@ -5,6 +5,7 @@ const TPL = `
     <style>
     .note-detail-read-only-code {
         position: relative;
+        min-height: 50px;
     }
     
     .note-detail-read-only-code-content {

src/public/app/widgets/type_widgets/read_only_text.js

@@ -14,22 +14,18 @@ const TPL = `
     .note-detail-readonly-text h5 { font-size: 1.2em; }
     .note-detail-readonly-text h6 { font-size: 1.1em; }
     
-    .note-detail-readonly-text h2 { font-size: 1.8em; } 
+    body.heading-style-markdown .note-detail-readonly-text h2::before { content: "##\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h2::before { content: "##\\2004"; color: var(--muted-text-color); }
+    body.heading-style-markdown .note-detail-readonly-text h3::before { content: "###\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h3 { font-size: 1.6em; }
+    body.heading-style-markdown .note-detail-readonly-text h4:not(.include-note-title)::before { content: "####\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h3::before { content: "###\\2004"; color: var(--muted-text-color); }
+    body.heading-style-markdown .note-detail-readonly-text h5::before { content: "#####\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h4 { font-size: 1.4em; }
+    body.heading-style-markdown .note-detail-readonly-text h6::before { content: "######\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h4:not(.include-note-title)::before { content: "####\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h5 { font-size: 1.2em; }
-    .note-detail-readonly-text h5::before { content: "#####\\2004"; color: var(--muted-text-color); }
-    .note-detail-readonly-text h6 { font-size: 1.1em; }
-    .note-detail-readonly-text h6::before { content: "######\\2004"; color: var(--muted-text-color); }
     
     .note-detail-readonly-text {
         padding-left: 22px;
         padding-top: 10px;
         font-family: var(--detail-text-font-family);
         position: relative;
+        min-height: 50px;
     }
         
     .note-detail-readonly-text p:first-child, .note-detail-readonly-text::before {
@@ -38,6 +34,7 @@ const TPL = `
     
     .note-detail-readonly-text img {
         max-width: 100%;
+        cursor: pointer;
     }
     
     .edit-text-note-container {
@@ -70,6 +67,8 @@ export default class ReadOnlyTextTypeWidget extends AbstractTextTypeWidget {
             this.triggerEvent('textPreviewDisabled', {tabContext: this.tabContext});
         });
 
+        this.setupImageOpening(true);
+
         super.doRender();
     }
 

src/public/app/widgets/type_widgets/relation_map.js

@@ -7,6 +7,7 @@ import attributeAutocompleteService from "../../services/attribute_autocomplete.
 import TypeWidget from "./type_widget.js";
 import appContext from "../../services/app_context.js";
 import utils from "../../services/utils.js";
+import treeCache from "../../services/tree_cache.js";
 
 const uniDirectionalOverlays = [
     [ "Arrow", {
@@ -531,8 +532,11 @@ export default class RelationMapTypeWidget extends TypeWidget {
             linkService.goToLink(e);
         });
 
+        const note = await treeCache.getNote(noteId);
+
         const $noteBox = $("<div>")
             .addClass("note-box")
+            .addClass(note.getCssClass())
             .prop("id", this.noteIdToId(noteId))
             .append($("<span>").addClass("title").append($link))
             .append($("<div>").addClass("endpoint").attr("title", "Start dragging relations from here and drop them on another note."))

src/routes/api/clipper.js

@@ -106,8 +106,12 @@ function processContent(images, note, content) {
         for (const {src, dataUrl, imageId} of images) {
             const filename = path.basename(src);
 
-            if (!dataUrl.startsWith("data:image")) {
+            if (!dataUrl || !dataUrl.startsWith("data:image")) {
-                log.info("Image could not be recognized as data URL:", dataUrl.substr(0, Math.min(100, dataUrl.length)));
+                const excerpt = dataUrl
+                    ? dataUrl.substr(0, Math.min(100, dataUrl.length))
+                    : "null";
+
+                log.info("Image could not be recognized as data URL: " + excerpt);
                 continue;
             }
 

src/routes/api/date_notes.js

@@ -5,10 +5,31 @@ const sql = require('../../services/sql');
 const dateUtils = require('../../services/date_utils');
 const noteService = require('../../services/notes');
 const attributeService = require('../../services/attributes');
+const cls = require('../../services/cls');
+const repository = require('../../services/repository');
 
 function getInboxNote(req) {
-    return attributeService.getNoteWithLabel('inbox')
+    const hoistedNote = getHoistedNote();
+
+    let inbox;
+
+    if (hoistedNote) {
+        ([inbox] = hoistedNote.getDescendantNotesWithLabel('hoistedInbox'));
+
+        if (!inbox) {
+            ([inbox] = hoistedNote.getDescendantNotesWithLabel('inbox'));
+        }
+
+        if (!inbox) {
+            inbox = hoistedNote;
+        }
+    }
+    else {
+        inbox = attributeService.getNoteWithLabel('inbox')
             || dateNoteService.getDateNote(req.params.date);
+    }
+
+    return inbox;
 }
 
 function getDateNote(req) {
@@ -62,12 +83,33 @@ function createSqlConsole() {
 function createSearchNote(req) {
     const params = req.body;
     const searchString = params.searchString || "";
+    let ancestorNoteId = params.ancestorNoteId;
 
+    const hoistedNote = getHoistedNote();
+
+    let searchHome;
+
+    if (hoistedNote) {
+        ([searchHome] = hoistedNote.getDescendantNotesWithLabel('hoistedSearchHome'));
+
+        if (!searchHome) {
+            ([searchHome] = hoistedNote.getDescendantNotesWithLabel('searchHome'));
+        }
+
+        if (!searchHome) {
+            searchHome = hoistedNote;
+        }
+
+        if (!ancestorNoteId) {
+            ancestorNoteId = hoistedNote.noteId;
+        }
+    }
+    else {
         const today = dateUtils.localNowDate();
 
-    const searchHome =
+        searchHome = attributeService.getNoteWithLabel('searchHome')
-        attributeService.getNoteWithLabel('searchHome')
                   || dateNoteService.getDateNote(today);
+    }
 
     const {note} = noteService.createNewNote({
         parentNoteId: searchHome.noteId,
@@ -79,13 +121,19 @@ function createSearchNote(req) {
 
     note.setLabel('searchString', searchString);
 
-    if (params.ancestorNoteId) {
+    if (ancestorNoteId) {
-        note.setRelation('ancestor', params.ancestorNoteId);
+        note.setRelation('ancestor', ancestorNoteId);
     }
 
     return note;
 }
 
+function getHoistedNote() {
+    return cls.getHoistedNoteId() && cls.getHoistedNoteId() !== 'root'
+        ? repository.getNote(cls.getHoistedNoteId())
+        : null;
+}
+
 module.exports = {
     getInboxNote,
     getDateNote,

src/routes/api/login.js

@@ -78,6 +78,12 @@ function loginToProtectedSession(req) {
     };
 }
 
+function logoutFromProtectedSession() {
+    protectedSessionService.resetDataKey();
+
+    eventService.emit(eventService.LEAVE_PROTECTED_SESSION);
+}
+
 function token(req) {
     const username = req.body.username;
     const password = req.body.password;
@@ -101,5 +107,6 @@ function token(req) {
 module.exports = {
     loginSync,
     loginToProtectedSession,
+    logoutFromProtectedSession,
     token
 };

src/routes/api/note_revisions.js

@@ -5,6 +5,7 @@ const noteCacheService = require('../../services/note_cache/note_cache_service')
 const protectedSessionService = require('../../services/protected_session');
 const noteRevisionService = require('../../services/note_revisions');
 const utils = require('../../services/utils');
+const sql = require('../../services/sql');
 const path = require('path');
 
 function getNoteRevisions(req) {

src/routes/api/notes.js

@@ -4,6 +4,7 @@ const noteService = require('../../services/notes');
 const treeService = require('../../services/tree');
 const repository = require('../../services/repository');
 const utils = require('../../services/utils');
+const log = require('../../services/log');
 const TaskContext = require('../../services/task_context');
 
 function getNote(req) {
@@ -85,10 +86,20 @@ function undeleteNote(req) {
     taskContext.taskSucceeded();
 }
 
-function sortNotes(req) {
+function sortChildNotes(req) {
     const noteId = req.params.noteId;
+    const {sortBy, sortDirection} = req.body;
 
-    treeService.sortNotesAlphabetically(noteId);
+    log.info(`Sorting ${noteId} children with ${sortBy} ${sortDirection}`);
+
+    const reverse = sortDirection === 'desc';
+
+    if (sortBy === 'title') {
+        treeService.sortNotesByTitle(noteId, false, reverse);
+    }
+    else {
+        treeService.sortNotes(noteId, sortBy, reverse);
+    }
 }
 
 function protectNote(req) {
@@ -215,7 +226,7 @@ module.exports = {
     deleteNote,
     undeleteNote,
     createNote,
-    sortNotes,
+    sortChildNotes,
     protectNote,
     setNoteTypeMime,
     getRelationMap,

src/routes/api/options.js

@@ -40,7 +40,9 @@ const ALLOWED_OPTIONS = new Set([
     'nativeTitleBarVisible',
     'attributeListExpanded',
     'promotedAttributesExpanded',
-    'similarNotesExpanded'
+    'similarNotesExpanded',
+    'headingStyle',
+    'autoCollapseNoteTree'
 ]);
 
 function getOptions() {

src/routes/api/sync.js

@@ -200,9 +200,7 @@ function queueSector(req) {
     const entityName = utils.sanitizeSqlIdentifier(req.params.entityName);
     const sector = utils.sanitizeSqlIdentifier(req.params.sector);
 
-    const entityPrimaryKey = entityConstructor.getEntityFromEntityName(entityName).primaryKeyName;
+    entityChangesService.addEntityChangesForSector(entityName, sector);
-
-    entityChangesService.addEntityChangesForSector(entityName, entityPrimaryKey, sector);
 }
 
 module.exports = {

src/routes/index.js

@@ -19,6 +19,7 @@ function index(req, res) {
     res.render(view, {
         csrfToken: csrfToken,
         theme: options.theme,
+        headingStyle: options.headingStyle,
         mainFontSize: parseInt(options.mainFontSize),
         treeFontSize: parseInt(options.treeFontSize),
         detailFontSize: parseInt(options.detailFontSize),

src/routes/routes.js

@@ -150,7 +150,7 @@ function register(app) {
     apiRoute(DELETE, '/api/notes/:noteId', notesApiRoute.deleteNote);
     apiRoute(PUT, '/api/notes/:noteId/undelete', notesApiRoute.undeleteNote);
     apiRoute(POST, '/api/notes/:parentNoteId/children', notesApiRoute.createNote);
-    apiRoute(PUT, '/api/notes/:noteId/sort', notesApiRoute.sortNotes);
+    apiRoute(PUT, '/api/notes/:noteId/sort-children', notesApiRoute.sortChildNotes);
     apiRoute(PUT, '/api/notes/:noteId/protect/:isProtected', notesApiRoute.protectNote);
     apiRoute(PUT, /\/api\/notes\/(.*)\/type\/(.*)\/mime\/(.*)/, notesApiRoute.setNoteTypeMime);
     apiRoute(GET, '/api/notes/:noteId/revisions', noteRevisionsApiRoute.getNoteRevisions);
@@ -270,6 +270,8 @@ function register(app) {
     route(POST, '/api/login/sync', [], loginApiRoute.loginSync, apiResultHandler);
     // this is for entering protected mode so user has to be already logged-in (that's the reason we don't require username)
     apiRoute(POST, '/api/login/protected', loginApiRoute.loginToProtectedSession);
+    apiRoute(POST, '/api/logout/protected', loginApiRoute.logoutFromProtectedSession);
+
     route(POST, '/api/login/token', [], loginApiRoute.token, apiResultHandler);
 
     // in case of local electron, local calls are allowed unauthenticated, for server they need auth

src/services/attributes.js

@@ -27,7 +27,6 @@ const BUILTIN_ATTRIBUTES = [
     { type: 'label', name: 'run', isDangerous: true },
     { type: 'label', name: 'customRequestHandler', isDangerous: true },
     { type: 'label', name: 'customResourceProvider', isDangerous: true },
-    { type: 'label', name: 'bookZoomLevel', isDangerous: false },
     { type: 'label', name: 'widget', isDangerous: true },
     { type: 'label', name: 'noteInfoWidgetDisabled' },
     { type: 'label', name: 'linkMapWidgetDisabled' },
@@ -38,8 +37,12 @@ const BUILTIN_ATTRIBUTES = [
     { type: 'label', name: 'workspaceIconClass' },
     { type: 'label', name: 'workspaceTabBackgroundColor' },
     { type: 'label', name: 'searchHome' },
+    { type: 'label', name: 'hoistedInbox' },
+    { type: 'label', name: 'hoistedSearchHome' },
     { type: 'label', name: 'sqlConsoleHome' },
     { type: 'label', name: 'datePattern' },
+    { type: 'label', name: 'pageSize' },
+    { type: 'label', name: 'viewType' },
 
     // relation names
     { type: 'relation', name: 'runOnNoteCreation', isDangerous: true },

src/services/backend_script_api.js

@@ -359,7 +359,7 @@ function BackendScriptApi(currentNote, apiParams) {
      * @method
      * @param {string} parentNoteId - this note's child notes will be sorted
      */
-    this.sortNotesAlphabetically = treeService.sortNotesAlphabetically;
+    this.sortNotesByTitle = treeService.sortNotesByTitle;
 
     /**
      * This method finds note by its noteId and prefix and either sets it to the given parentNoteId

src/services/build.js

@@ -1 +1 @@
-module.exports = { buildDate:"2021-02-25T22:41:35+01:00", buildRevision: "cde41b268e4e88b3fe3601d9d19b3f5241625ada" };
+module.exports = { buildDate:"2021-04-22T20:50:22+02:00", buildRevision: "c27f573eed8905fc1d958adf5bdee0efc3aff593" };

src/services/cls.js

@@ -44,10 +44,14 @@ function isEntityEventsDisabled() {
     return !!namespace.get('disableEntityEvents');
 }
 
+function clearEntityChanges() {
+    namespace.set('entityChanges', []);
+}
+
 function getAndClearEntityChanges() {
     const entityChanges = namespace.get('entityChanges') || [];
 
-    namespace.set('entityChanges', []);
+    clearEntityChanges();
 
     return entityChanges;
 }
@@ -92,6 +96,7 @@ module.exports = {
     disableEntityEvents,
     isEntityEventsDisabled,
     reset,
+    clearEntityChanges,
     getAndClearEntityChanges,
     addEntityChange,
     getEntityFromCache,

src/services/entity_changes.js

@@ -30,28 +30,37 @@ function addEntityChange(entityChange, sourceId, isSynced) {
     cls.addEntityChange(localEntityChange);
 }
 
+function addNoteReorderingEntityChange(parentNoteId, sourceId) {
+    addEntityChange({
+        entityName: "note_reordering",
+        entityId: parentNoteId,
+        hash: 'N/A',
+        isErased: false,
+        utcDateChanged: dateUtils.utcNowDateTime()
+    }, sourceId);
+
+    const eventService = require('./events');
+
+    eventService.emit(eventService.ENTITY_CHANGED, {
+        entityName: 'note_reordering',
+        entity: sql.getMap(`SELECT branchId, notePosition FROM branches WHERE isDeleted = 0 AND parentNoteId = ?`, [parentNoteId])
+    });
+}
+
 function moveEntityChangeToTop(entityName, entityId) {
     const [hash, isSynced] = sql.getRow(`SELECT * FROM entity_changes WHERE entityName = ? AND entityId = ?`, [entityName, entityId]);
 
     addEntityChange(entityName, entityId, hash, null, isSynced);
 }
 
-function addEntityChangesForSector(entityName, entityPrimaryKey, sector) {
+function addEntityChangesForSector(entityName, sector) {
     const startTime = Date.now();
-    const repository = require('./repository');
+
+    const entityChanges = sql.getRows(`SELECT * FROM entity_changes WHERE entityName = ? AND SUBSTR(entityId, 1, 1) = ?`, [entityName, sector]);
 
     sql.transactional(() => {
-        const entityIds = sql.getColumn(`SELECT ${entityPrimaryKey} FROM ${entityName} WHERE SUBSTR(${entityPrimaryKey}, 1, 1) = ?`, [sector]);
+        for (const ec of entityChanges) {
-
+            insertEntityChange(entityName, ec.entityId, ec.hash, ec.isErased, ec.utcDateChanged, ec.sourceId, ec.isSynced);
-        for (const entityId of entityIds) {
-            // retrieving entity one by one to avoid memory issues with note_contents
-            const entity = repository.getEntity(`SELECT * FROM ${entityName} WHERE ${entityPrimaryKey} = ?`, [entityId]);
-
-            if (entityName === 'options' && !entity.isSynced) {
-                continue
-            }
-
-            insertEntityChange(entityName, entityId, entity.generateHash(), false, entity.getUtcDateChanged(), 'content-check', true);
         }
     });
 
@@ -121,13 +130,7 @@ function fillAllEntityChanges() {
 }
 
 module.exports = {
-    addNoteReorderingEntityChange: (parentNoteId, sourceId) => addEntityChange({
+    addNoteReorderingEntityChange,
-        entityName: "note_reordering",
-        entityId: parentNoteId,
-        hash: 'N/A',
-        isErased: false,
-        utcDateChanged: dateUtils.utcNowDateTime()
-    }, sourceId),
     moveEntityChangeToTop,
     addEntityChange,
     fillAllEntityChanges,

src/services/events.js

@@ -2,6 +2,7 @@ const log = require('./log');
 
 const NOTE_TITLE_CHANGED = "NOTE_TITLE_CHANGED";
 const ENTER_PROTECTED_SESSION = "ENTER_PROTECTED_SESSION";
+const LEAVE_PROTECTED_SESSION = "LEAVE_PROTECTED_SESSION";
 const ENTITY_CREATED = "ENTITY_CREATED";
 const ENTITY_CHANGED = "ENTITY_CHANGED";
 const ENTITY_DELETED = "ENTITY_DELETED";
@@ -47,6 +48,7 @@ module.exports = {
     // event types:
     NOTE_TITLE_CHANGED,
     ENTER_PROTECTED_SESSION,
+    LEAVE_PROTECTED_SESSION,
     ENTITY_CREATED,
     ENTITY_CHANGED,
     ENTITY_DELETED,

src/services/handlers.js

@@ -31,7 +31,7 @@ eventService.subscribe(eventService.NOTE_TITLE_CHANGED, note => {
 
         for (const parentNote of noteFromCache.parents) {
             if (parentNote.hasLabel("sorted")) {
-                treeService.sortNotesAlphabetically(parentNote.noteId);
+                treeService.sortNotesByTitle(parentNote.noteId);
             }
         }
     }
@@ -53,23 +53,19 @@ eventService.subscribe(eventService.ENTITY_CREATED, ({ entityName, entity }) =>
         if (entity.type === 'relation' && entity.name === 'template') {
             const note = repository.getNote(entity.noteId);
 
-            if (!["text", "code"].includes(note.type)) {
-                return;
-            }
-
-            const content = note.getContent();
-
-            if (content && content.trim().length > 0) {
-                return;
-            }
-
             const templateNote = repository.getNote(entity.value);
 
             if (!templateNote) {
                 return;
             }
 
-            if (templateNote.isStringNote()) {
+            const content = note.getContent();
+
+            if (["text", "code"].includes(note.type)
+                // if the note has already content we're not going to overwrite it with template's one
+                && (!content || content.trim().length === 0)
+                && templateNote.isStringNote()) {
+
                 const templateNoteContent = templateNote.getContent();
 
                 if (templateNoteContent) {
@@ -81,17 +77,21 @@ eventService.subscribe(eventService.ENTITY_CREATED, ({ entityName, entity }) =>
                 note.save();
             }
 
+            // we'll copy the children notes only if there's none so far
+            // this protects against e.g. multiple assignment of template relation resulting in having multiple copies of the subtree
+            if (note.getChildNotes().length === 0 && !note.isDescendantOfNote(templateNote.noteId)) {
                 noteService.duplicateSubtreeWithoutRoot(templateNote.noteId, note.noteId);
             }
+        }
         else if (entity.type === 'label' && entity.name === 'sorted') {
-            treeService.sortNotesAlphabetically(entity.noteId);
+            treeService.sortNotesByTitle(entity.noteId);
 
             if (entity.isInheritable) {
                 const note = noteCache.notes[entity.noteId];
 
                 if (note) {
                     for (const noteId of note.subtreeNoteIds) {
-                        treeService.sortNotesAlphabetically(noteId);
+                        treeService.sortNotesByTitle(noteId);
                     }
                 }
             }

src/services/import/zip.js

@@ -463,7 +463,7 @@ async function importZip(taskContext, fileBuffer, importRootNote) {
         if (!metaFile) {
             // if there's no meta file then the notes are created based on the order in that tar file but that
             // is usually quite random so we sort the notes in the way they would appear in the file manager
-            treeService.sortNotesAlphabetically(noteId, true);
+            treeService.sortNotesByTitle(noteId, true);
         }
 
         taskContext.increaseProgressCount();

src/services/note_cache/entities/note.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const protectedSessionService = require('../../protected_session');
+const log = require('../../log');
 
 class Note {
     constructor(noteCache, row) {
@@ -405,7 +406,7 @@ class Note {
             return 0;
         }
 
-        let minDistance = 999_999;
+        let minDistance = 999999;
 
         for (const parent of this.parents) {
             minDistance = Math.min(minDistance, parent.getDistanceToAncestor(ancestorNoteId) + 1);
@@ -416,10 +417,15 @@ class Note {
 
     decrypt() {
         if (this.isProtected && !this.isDecrypted && protectedSessionService.isProtectedSessionAvailable()) {
+            try {
                 this.title = protectedSessionService.decryptString(this.title);
 
                 this.isDecrypted = true;
             }
+            catch (e) {
+                log.error(`Could not decrypt note ${this.noteId}: ${e.message} ${e.stack}`);
+            }
+        }
     }
 
     // for logging etc

src/services/note_cache/note_cache_loader.js

@@ -120,7 +120,11 @@ eventService.subscribe([eventService.ENTITY_CHANGED, eventService.ENTITY_DELETED
             delete noteCache.attributes[attributeId];
 
             if (attr) {
-                delete noteCache.attributeIndex[`${attr.type}-${attr.name.toLowerCase()}`];
+                const key = `${attr.type}-${attr.name.toLowerCase()}`;
+
+                if (key in noteCache.attributeIndex) {
+                    noteCache.attributeIndex[key] = noteCache.attributeIndex[key].filter(attr => attr.attributeId !== attributeId);
+                }
             }
         }
         else if (attributeId in noteCache.attributes) {
@@ -149,6 +153,19 @@ eventService.subscribe([eventService.ENTITY_CHANGED, eventService.ENTITY_DELETED
             }
         }
     }
+    else if (entityName === 'note_reordering') {
+        const parentNoteIds = new Set();
+
+        for (const branchId in entity) {
+            const branch = noteCache.branches[branchId];
+
+            if (branch) {
+                branch.notePosition = entity[branchId];
+
+                parentNoteIds.add(branch.parentNoteId);
+            }
+        }
+    }
 });
 
 eventService.subscribe(eventService.ENTER_PROTECTED_SESSION, () => {
@@ -160,6 +177,10 @@ eventService.subscribe(eventService.ENTER_PROTECTED_SESSION, () => {
     }
 });
 
+eventService.subscribe(eventService.LEAVE_PROTECTED_SESSION, () => {
+    load();
+});
+
 module.exports = {
     load
 };

src/services/note_cache/similarity.js

@@ -23,7 +23,6 @@ const IGNORED_ATTR_NAMES = [
     "archived",
     "hidepromotedattributes",
     "keyboardshortcut",
-    "bookzoomlevel",
     "noteinfowidgetdisabled",
     "linkmapwidgetdisabled",
     "noterevisionswidgetdisabled",
@@ -234,7 +233,7 @@ async function findSimilarNotes(noteId) {
 
     const baseNote = noteCache.notes[noteId];
 
-    if (!baseNote) {
+    if (!baseNote || !baseNote.utcDateCreated) {
         return [];
     }
 

src/services/options_init.js

@@ -84,7 +84,9 @@ const defaultOptions = [
     { name: 'attributeListExpanded', value: 'false', isSynced: false },
     { name: 'promotedAttributesExpanded', value: 'true', isSynced: true },
     { name: 'similarNotesExpanded', value: 'true', isSynced: true },
-    { name: 'debugModeEnabled', value: 'false', isSynced: false }
+    { name: 'debugModeEnabled', value: 'false', isSynced: false },
+    { name: 'headingStyle', value: 'markdown', isSynced: true },
+    { name: 'autoCollapseNoteTree', value: 'true', isSynced: true },
 ];
 
 function initStartupOptions() {

src/services/protected_session.js

@@ -5,7 +5,7 @@ const log = require('./log');
 const dataEncryptionService = require('./data_encryption');
 const cls = require('./cls');
 
-const dataKeyMap = {};
+let dataKeyMap = {};
 
 function setDataKey(decryptedDataKey) {
     const protectedSessionId = utils.randomSecureToken(32);
@@ -29,6 +29,10 @@ function getDataKey() {
     return dataKeyMap[protectedSessionId];
 }
 
+function resetDataKey() {
+    dataKeyMap = {};
+}
+
 function isProtectedSessionAvailable() {
     const protectedSessionId = getProtectedSessionId();
 
@@ -71,6 +75,7 @@ function decryptString(cipherText) {
 module.exports = {
     setDataKey,
     getDataKey,
+    resetDataKey,
     isProtectedSessionAvailable,
     encrypt,
     decrypt,

src/services/request.js

@@ -84,7 +84,15 @@ function exec(opts) {
                 });
             });
 
-            request.end(opts.body);
+            let payload;
+
+            if (opts.body) {
+                payload = typeof opts.body === 'object'
+                    ? JSON.stringify(opts.body)
+                    : opts.body;
+            }
+
+            request.end(payload);
         }
         catch (e) {
             reject(generateError(opts, e.message));

src/services/search/services/lex.js

@@ -21,8 +21,8 @@ function lex(str) {
         }
     }
 
-    function finishWord(endIndex) {
+    function finishWord(endIndex, createAlsoForEmptyWords = false) {
-        if (currentWord === '') {
+        if (currentWord === '' && !createAlsoForEmptyWords) {
             return;
         }
 
@@ -71,7 +71,7 @@ function lex(str) {
                 }
             }
             else if (quotes === chr) {
-                finishWord(i - 1);
+                finishWord(i - 1, true);
 
                 quotes = false;
             }

src/services/sql.js

@@ -3,6 +3,7 @@
 const log = require('./log');
 const Database = require('better-sqlite3');
 const dataDir = require('./data_dir');
+const cls = require('./cls');
 
 const dbConnection = new Database(dataDir.DOCUMENT_PATH);
 dbConnection.pragma('journal_mode = WAL');
@@ -31,7 +32,7 @@ function insert(tableName, rec, replace = false) {
 
     const res = execute(query, Object.values(rec));
 
-    return res.lastInsertRowid;
+    return res ? res.lastInsertRowid : null;
 }
 
 function replace(tableName, rec) {
@@ -229,6 +230,7 @@ function wrap(query, func) {
 }
 
 function transactional(func) {
+    try {
         const ret = dbConnection.transaction(func).deferred();
 
         if (!dbConnection.inTransaction) { // i.e. transaction was really committed (and not just savepoint released)
@@ -236,6 +238,12 @@ function transactional(func) {
         }
 
         return ret;
+    }
+    catch (e) {
+        cls.clearEntityChanges();
+
+        throw e;
+    }
 }
 
 function fillNoteIdList(noteIds, truncate = true) {

src/services/sync.js

@@ -245,9 +245,7 @@ async function checkContentHash(syncContext) {
     const failedChecks = contentHashService.checkContentHashes(resp.entityHashes);
 
     for (const {entityName, sector} of failedChecks) {
-        const entityPrimaryKey = entityConstructor.getEntityFromEntityName(entityName).primaryKeyName;
+        entityChangesService.addEntityChangesForSector(entityName, sector);
-
-        entityChangesService.addEntityChangesForSector(entityName, entityPrimaryKey, sector);
 
         await syncRequest(syncContext, 'POST', `/api/sync/queue-sector/${entityName}/${sector}`);
     }

src/services/sync_update.js

@@ -26,9 +26,7 @@ function updateEntity(entityChange, entity, sourceId) {
         ? updateNoteReordering(entityChange, entity, sourceId)
         : updateNormalEntity(entityChange, entity, sourceId);
 
-    // currently making exception for protected notes and note revisions because here
+    if (updated && !entityChange.isErased) {
-    // the title and content are not available decrypted as listeners would expect
-    if (updated && !entity.isProtected && !entityChange.isErased) {
         eventService.emit(eventService.ENTITY_SYNCED, {
             entityName: entityChange.entityName,
             entity
@@ -44,7 +42,7 @@ function updateNormalEntity(remoteEntityChange, entity, sourceId) {
 
     if (localEntityChange && !localEntityChange.isErased && remoteEntityChange.isErased) {
         sql.transactional(() => {
-            const primaryKey = entityConstructor.getEntityFromEntityName(entityName).primaryKeyName;
+            const primaryKey = entityConstructor.getEntityFromEntityName(remoteEntityChange.entityName).primaryKeyName;
 
             sql.execute(`DELETE FROM ${remoteEntityChange.entityName} WHERE ${primaryKey} = ?`, remoteEntityChange.entityId);
 

src/services/tree.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const sql = require('./sql');
+const log = require('./log');
 const repository = require('./repository');
 const Branch = require('../entities/branch');
 const entityChangesService = require('./entity_changes.js');
@@ -106,7 +107,7 @@ function loadSubtreeNoteIds(parentNoteId, subtreeNoteIds) {
     }
 }
 
-function sortNotesAlphabetically(parentNoteId, directoriesFirst = false) {
+function sortNotesByTitle(parentNoteId, foldersFirst = false, reverse = false) {
     sql.transactional(() => {
         const notes = sql.getRows(
             `SELECT branches.branchId, notes.noteId, title, isProtected, 
@@ -120,7 +121,7 @@ function sortNotesAlphabetically(parentNoteId, directoriesFirst = false) {
         protectedSessionService.decryptNotes(notes);
 
         notes.sort((a, b) => {
-            if (directoriesFirst && ((a.hasChildren && !b.hasChildren) || (!a.hasChildren && b.hasChildren))) {
+            if (foldersFirst && ((a.hasChildren && !b.hasChildren) || (!a.hasChildren && b.hasChildren))) {
                 // exactly one note of the two is a directory so the sorting will be done based on this status
                 return a.hasChildren ? -1 : 1;
             }
@@ -129,13 +130,49 @@ function sortNotesAlphabetically(parentNoteId, directoriesFirst = false) {
             }
         });
 
+        if (reverse) {
+            notes.reverse();
+        }
+
         let position = 10;
 
         for (const note of notes) {
             sql.execute("UPDATE branches SET notePosition = ? WHERE branchId = ?",
                 [position, note.branchId]);
 
+            if (note.branchId in noteCache.branches) {
                 noteCache.branches[note.branchId].notePosition = position;
+            }
+            else {
+                log.info(`Branch "${note.branchId}" was not found in note cache.`);
+            }
+
+            position += 10;
+        }
+
+        entityChangesService.addNoteReorderingEntityChange(parentNoteId);
+    });
+}
+
+function sortNotes(parentNoteId, sortBy, reverse = false) {
+    sql.transactional(() => {
+        const notes = repository.getNote(parentNoteId).getChildNotes();
+
+        notes.sort((a, b) => a[sortBy] < b[sortBy] ? -1 : 1);
+
+        if (reverse) {
+            notes.reverse();
+        }
+
+        let position = 10;
+
+        for (const note of notes) {
+            const branch = note.getBranches().find(b => b.parentNoteId === parentNoteId);
+
+            sql.execute("UPDATE branches SET notePosition = ? WHERE branchId = ?",
+                [position, branch.branchId]);
+
+            noteCache.branches[branch.branchId].notePosition = position;
 
             position += 10;
         }
@@ -194,6 +231,7 @@ function setNoteToParent(noteId, prefix, parentNoteId) {
 module.exports = {
     getNotes,
     validateParentChild,
-    sortNotesAlphabetically,
+    sortNotesByTitle,
+    sortNotes,
     setNoteToParent
 };

src/services/ws.js

@@ -106,8 +106,6 @@ function sendPing(client, entityChanges = []) {
         }
     }
 
-    const stats = require('./sync').stats;
-
     sendMessage(client, {
         type: 'sync',
         data: entityChanges
@@ -118,9 +116,7 @@ function sendTransactionSyncsToAllClients() {
     if (webSocketServer) {
         const entityChanges = cls.getAndClearEntityChanges();
 
-        webSocketServer.clients.forEach(function each(client) {
+        webSocketServer.clients.forEach(client => sendPing(client, entityChanges));
-           sendPing(client, entityChanges);
-        });
     }
 }
 

src/views/desktop.ejs

@@ -5,7 +5,7 @@
     <link rel="shortcut icon" href="favicon.ico">
     <title>Trilium Notes</title>
 </head>
-<body class="desktop theme-<%= theme %>" style="--main-font-size: <%= mainFontSize %>%; --tree-font-size: <%= treeFontSize %>%; --detail-font-size: <%= detailFontSize %>%;">
+<body class="desktop theme-<%= theme %> heading-style-<%= headingStyle %>" style="--main-font-size: <%= mainFontSize %>%; --tree-font-size: <%= treeFontSize %>%; --detail-font-size: <%= detailFontSize %>%;">
 <noscript>Trilium requires JavaScript to be enabled.</noscript>
 
 <script>
@@ -39,6 +39,7 @@
 <%- include('dialogs/move_to.ejs') %>
 <%- include('dialogs/backend_log.ejs') %>
 <%- include('dialogs/include_note.ejs') %>
+<%- include('dialogs/sort_child_notes.ejs') %>
 
 <script type="text/javascript">
     window.baseApiUrl = 'api/';

src/views/dialogs/sort_child_notes.ejs

@@ -0,0 +1,60 @@
+<div id="sort-child-notes-dialog" class="modal mx-auto" tabindex="-1" role="dialog">
+    <div class="modal-dialog modal-lg" style="max-width: 500px" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title mr-auto">Sort children by ...</h5>
+
+                <button type="button" class="close" data-dismiss="modal" aria-label="Close" style="margin-left: 0 !important;">
+                    <span aria-hidden="true">&times;</span>
+                </button>
+            </div>
+            <form id="sort-child-notes-form">
+                <div class="modal-body">
+                    <h5>Sorting criteria</h5>
+
+                    <div class="form-check">
+                        <input class="form-check-input" type="radio" name="sort-by" value="title" id="sort-by-title" checked>
+                        <label class="form-check-label" for="sort-by-title">
+                            title
+                        </label>
+                    </div>
+
+                    <div class="form-check">
+                        <input class="form-check-input" type="radio" name="sort-by" value="dateCreated" id="sort-by-date-created">
+                        <label class="form-check-label" for="sort-by-date-created">
+                            date created
+                        </label>
+                    </div>
+
+                    <div class="form-check">
+                        <input class="form-check-input" type="radio" name="sort-by" value="dateModified" id="sort-by-date-modified">
+                        <label class="form-check-label" for="sort-by-date-modified">
+                            date modified
+                        </label>
+                    </div>
+
+                    <br/>
+
+                    <h5>Sorting direction</h5>
+
+                    <div class="form-check">
+                        <input class="form-check-input" type="radio" name="sort-direction" value="asc" id="sort-direction-asc" checked>
+                        <label class="form-check-label" for="sort-direction-asc">
+                            ascending
+                        </label>
+                    </div>
+
+                    <div class="form-check">
+                        <input class="form-check-input" type="radio" name="sort-direction" value="desc" id="sort-direction-desc">
+                        <label class="form-check-label" for="sort-direction-desc">
+                            descending
+                        </label>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="submit" class="btn btn-primary">Sort <kbd>enter</kbd></button>
+                </div>
+            </form>
+        </div>
+    </div>
+</div>

src/views/mobile.ejs

@@ -95,7 +95,7 @@
         }
     </style>
 </head>
-<body class="mobile theme-<%= theme %>">
+<body class="mobile theme-<%= theme %> heading-style-<%= headingStyle %>">
 <noscript>Trilium requires JavaScript to be enabled.</noscript>
 
 <div id="toast-container" class="d-flex flex-column justify-content-center align-items-center"></div>

trilium.iml

@@ -7,6 +7,9 @@
       <sourceFolder url="file://$MODULE_DIR$/src/public" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/dist" />
       <excludeFolder url="file://$MODULE_DIR$/src/public/app-dist" />
+      <excludeFolder url="file://$MODULE_DIR$/libraries" />
+      <excludeFolder url="file://$MODULE_DIR$/docs" />
+      <excludeFolder url="file://$MODULE_DIR$/bin/better-sqlite3" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />