6.7.0 - Alpha6 - Scrapers 工具的更新机制由 "锚点更新" 替换为 "结构化更新"

.utils/utils/sorting.mjs

@@ -0,0 +1,75 @@
+// utils/sorting.mjs
+
+import { compareVersionStrings } from './versioning.mjs';
+
+/**
+ * @param {[string, string][] | MapIterator<[string, string]> | Map<string, string>} src
+ * @param {MapSortable['sort'] | null} [pattern=null]
+ * @returns {[string, string][]}
+ */
+export function sortByMap(src, pattern = null) {
+    const entries = src instanceof Map ? Array.from(src.entries()) : Array.from(src);
+    switch (pattern) {
+        case null:
+            return entries;
+        case 'key.ascending':
+        case 'key.ascending.as.string':
+            return entries.sort((a, b) => a[0].localeCompare(b[0]));
+        case 'key.ascending.as.number':
+            return entries.sort((a, b) => Number(a[0]) - Number(b[0]));
+        case 'key.ascending.as.version':
+            return entries.sort((a, b) => compareVersionStrings(a[0], b[0]));
+        case 'key.descending':
+        case 'key.descending.as.string':
+            return entries.sort((a, b) => b[0].localeCompare(a[0]));
+        case 'key.descending.as.number':
+            return entries.sort((a, b) => Number(b[0]) - Number(a[0]));
+        case 'key.descending.as.version':
+            return entries.sort((a, b) => compareVersionStrings(b[0], a[0]));
+        case 'value.ascending':
+        case 'value.ascending.as.string':
+            return entries.sort((a, b) => a[1].localeCompare(b[1]));
+        case 'value.ascending.as.number':
+            return entries.sort((a, b) => Number(a[1]) - Number(b[1]));
+        case 'value.ascending.as.version':
+            return entries.sort((a, b) => compareVersionStrings(a[1], b[1]));
+        case 'value.descending':
+        case 'value.descending.as.string':
+            return entries.sort((a, b) => b[1].localeCompare(a[1]));
+        case 'value.descending.as.number':
+            return entries.sort((a, b) => Number(b[1]) - Number(a[1]));
+        case 'value.descending.as.version':
+            return entries.sort((a, b) => compareVersionStrings(b[1], a[1]));
+        default:
+            throw new Error(`Unknown sorting pattern: ${pattern}`);
+    }
+}
+
+/**
+ * @param {string[] | SetIterator<string> | Set<string>} src
+ * @param {ListSortable['sort'] | null} [pattern=null]
+ * @returns {string[]}
+ */
+export function sortByList(src, pattern = null) {
+    const values = src instanceof Set ? Array.from(src.values()) : Array.from(src);
+    switch (pattern) {
+        case null:
+            return values;
+        case 'ascending':
+        case 'ascending.as.string':
+            return values.sort((a, b) => a.localeCompare(b));
+        case 'ascending.as.number':
+            return values.sort((a, b) => Number(a) - Number(b));
+        case 'ascending.as.version':
+            return values.sort((a, b) => compareVersionStrings(a, b));
+        case 'descending':
+        case 'descending.as.string':
+            return values.sort((a, b) => b.localeCompare(a));
+        case 'descending.as.number':
+            return values.sort((a, b) => Number(b) - Number(a));
+        case 'descending.as.version':
+            return values.sort((a, b) => compareVersionStrings(b, a));
+        default:
+            throw new Error(`Unknown sorting pattern: ${pattern}`);
+    }
+}