support updatable dictionaries

ext/css/settings.css

@@ -2324,6 +2324,7 @@ input[type=number].dictionary-priority {
     margin-right: 0.5em;
 }
 .dictionary-outdated-button,
+.dictionary-update-available,
 .dictionary-integrity-button {
     --button-content-color: transparent;
     --button-border-color: transparent;

ext/data/schemas/dictionary-index-schema.json

@@ -21,7 +21,7 @@
         },
         "revision": {
             "type": "string",
-            "description": "Revision of the dictionary. This value is only used for displaying information."
+            "description": "Revision of the dictionary. This value is displayed, and used to check for dictionary updates."
         },
         "sequenced": {
             "type": "boolean",
@@ -42,9 +42,22 @@
             "type": "string",
             "description": "Creator of the dictionary."
         },
+        "isUpdatable": {
+            "type": "boolean",
+            "const": true,
+            "description": "Whether this dictionary contains links to its latest version."
+        },
+        "indexUrl": {
+            "type": "string",
+            "description": "URL for the index file of the latest revision of the dictionary, used to check for updates."
+        },
+        "downloadUrl": {
+            "type": "string",
+            "description": "URL for the download of the latest revision of the dictionary."
+        },
         "url": {
             "type": "string",
-            "description": "URL for the source of the dictionary."
+            "description": "URL for the source of the dictionary, displayed in the dictionary details."
         },
         "description": {
             "type": "string",
@@ -101,5 +114,8 @@
         {
             "required": ["version"]
         }
-    ]
+    ],
+    "dependencies": {
+        "isUpdatable": ["indexUrl", "downloadUrl"]
+    }
 }

ext/js/dictionary/dictionary-data-util.js

@@ -296,6 +296,33 @@ export function isNonNounVerbOrAdjective(wordClasses) {
     return isVerbOrAdjective && !(isSuruVerb && isNoun);
 }
 
+/**
+ * @param {string} current
+ * @param {string} latest
+ * @returns {boolean}
+ */
+export function compareRevisions(current, latest) {
+    const simpleVersionTest = /^(\d+\.)*\d+$/; // dot-separated integers, so 4.7 or 24.1.1.1 are ok, 1.0.0-alpha is not
+    if (!simpleVersionTest.test(current) || !simpleVersionTest.test(latest)) {
+        return current < latest;
+    }
+
+    const currentParts = current.split('.').map((part) => Number.parseInt(part, 10));
+    const latestParts = latest.split('.').map((part) => Number.parseInt(part, 10));
+
+    if (currentParts.length !== latestParts.length) {
+        return current < latest;
+    }
+
+    for (let i = 0; i < currentParts.length; i++) {
+        if (currentParts[i] !== latestParts[i]) {
+            return currentParts[i] < latestParts[i];
+        }
+    }
+
+    return false;
+}
+
 // Private
 
 /**

ext/js/dictionary/dictionary-importer.js

@@ -311,6 +311,7 @@ export class DictionaryImporter {
      * @param {import('dictionary-data').Index} index
      * @param {import('dictionary-importer').SummaryDetails} details
      * @returns {import('dictionary-importer').Summary}
+     * @throws {Error}
      */
     _createSummary(dictionaryTitle, version, index, details) {
         const indexSequenced = index.sequenced;
@@ -327,18 +328,45 @@ export class DictionaryImporter {
             styles,
         };
 
-        const {author, url, description, attribution, frequencyMode, sourceLanguage, targetLanguage} = index;
+        const {author, url, description, attribution, frequencyMode, isUpdatable, sourceLanguage, targetLanguage} = index;
         if (typeof author === 'string') { summary.author = author; }
         if (typeof url === 'string') { summary.url = url; }
         if (typeof description === 'string') { summary.description = description; }
         if (typeof attribution === 'string') { summary.attribution = attribution; }
         if (typeof frequencyMode === 'string') { summary.frequencyMode = frequencyMode; }
         if (typeof sourceLanguage === 'string') { summary.sourceLanguage = sourceLanguage; }
         if (typeof targetLanguage === 'string') { summary.targetLanguage = targetLanguage; }
-
+        if (typeof isUpdatable === 'boolean') {
+            const {indexUrl, downloadUrl} = index;
+            if (!isUpdatable || !this._validateUrl(indexUrl) || !this._validateUrl(downloadUrl)) {
+                throw new Error('Invalid index data for updatable dictionary');
+            }
+            summary.isUpdatable = isUpdatable;
+            summary.indexUrl = indexUrl;
+            summary.downloadUrl = downloadUrl;
+        }
         return summary;
     }
 
+    /**
+     * @param {string|undefined} string
+     * @returns {boolean}
+     */
+    _validateUrl(string) {
+        if (typeof string !== 'string') {
+            return false;
+        }
+
+        let url;
+        try {
+            url = new URL(string);
+        } catch (_) {
+            return false;
+        }
+
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+
     /**
      * @param {import('ajv').ValidateFunction} schema
      * @param {string} fileName

ext/js/pages/settings/collapsible-dictionary-controller.js

@@ -153,7 +153,7 @@ export class CollapsibleDictionaryController {
         nameNode.textContent = dictionary;
 
         /** @type {HTMLElement} */
-        const versionNode = querySelectorNotNull(node, '.dictionary-version');
+        const versionNode = querySelectorNotNull(node, '.dictionary-revision');
         versionNode.textContent = version;
 
         return querySelectorNotNull(node, '.definitions-collapsible');