aboutsummaryrefslogtreecommitdiff
path: root/viewer/src/services
diff options
context:
space:
mode:
Diffstat (limited to 'viewer/src/services')
-rw-r--r--viewer/src/services/dragscrollclickfix.ts52
-rw-r--r--viewer/src/services/indexfactory.ts101
-rw-r--r--viewer/src/services/indexsearch.ts70
-rw-r--r--viewer/src/services/navigation.ts71
4 files changed, 294 insertions, 0 deletions
diff --git a/viewer/src/services/dragscrollclickfix.ts b/viewer/src/services/dragscrollclickfix.ts
new file mode 100644
index 0000000..38eb106
--- /dev/null
+++ b/viewer/src/services/dragscrollclickfix.ts
@@ -0,0 +1,52 @@
1/* ldgallery - A static generator which turns a collection of tagged
2-- pictures into a searchable web gallery.
3--
4-- Copyright (C) 2019-2020 Guillaume FOUET
5--
6-- This program is free software: you can redistribute it and/or modify
7-- it under the terms of the GNU Affero General Public License as
8-- published by the Free Software Foundation, either version 3 of the
9-- License, or (at your option) any later version.
10--
11-- This program is distributed in the hope that it will be useful,
12-- but WITHOUT ANY WARRANTY; without even the implied warranty of
13-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14-- GNU Affero General Public License for more details.
15--
16-- You should have received a copy of the GNU Affero General Public License
17-- along with this program. If not, see <https://www.gnu.org/licenses/>.
18*/
19
20// https://github.com/donmbelembe/vue-dragscroll/issues/61
21export default class DragScrollClickFix {
22
23 readonly DRAG_DELAY = 250; // This is the minimal delay to consider a click to be a drag, mostly usefull for touch devices
24
25 timer: NodeJS.Timeout | null = null;
26 dragging: boolean = false;
27
28 onDragScrollStart() {
29 this.timer = setTimeout(() => this.onTimer(), this.DRAG_DELAY);
30 }
31
32 onTimer() {
33 this.timer = null;
34 this.dragging = true;
35 }
36
37 onDragScrollEnd() {
38 if (this.timer) {
39 clearTimeout(this.timer);
40 this.timer = null;
41 }
42 setTimeout(() => this.dragging = false);
43 }
44
45 onClickCapture(e: MouseEvent) {
46 if (this.dragging) {
47 this.dragging = false;
48 e.preventDefault();
49 e.stopPropagation();
50 }
51 }
52}
diff --git a/viewer/src/services/indexfactory.ts b/viewer/src/services/indexfactory.ts
new file mode 100644
index 0000000..a6bc865
--- /dev/null
+++ b/viewer/src/services/indexfactory.ts
@@ -0,0 +1,101 @@
1/* ldgallery - A static generator which turns a collection of tagged
2-- pictures into a searchable web gallery.
3--
4-- Copyright (C) 2019-2020 Guillaume FOUET
5--
6-- This program is free software: you can redistribute it and/or modify
7-- it under the terms of the GNU Affero General Public License as
8-- published by the Free Software Foundation, either version 3 of the
9-- License, or (at your option) any later version.
10--
11-- This program is distributed in the hope that it will be useful,
12-- but WITHOUT ANY WARRANTY; without even the implied warranty of
13-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14-- GNU Affero General Public License for more details.
15--
16-- You should have received a copy of the GNU Affero General Public License
17-- along with this program. If not, see <https://www.gnu.org/licenses/>.
18*/
19
20import { Operation } from '@/@types/Operation';
21import Navigation from '@/services/navigation';
22
23export default class IndexFactory {
24
25 public static generateTags(root: Gallery.Item | null): Tag.Index {
26 let tagsIndex: Tag.Index = {};
27 if (root) IndexFactory.pushTagsForItem(tagsIndex, root);
28 return tagsIndex;
29 }
30
31 // Pushes all tags for a root item (and its children) to the index
32 private static pushTagsForItem(tagsIndex: Tag.Index, item: Gallery.Item): void {
33 console.log("IndexingTagsFor: ", item.path);
34 if (item.properties.type === "directory") {
35 item.properties.items.forEach(item => this.pushTagsForItem(tagsIndex, item));
36 return; // Directories are not indexed
37 }
38 for (const tag of item.tags) {
39 const parts = tag.split('.');
40 let lastPart: string | null = null;
41 for (const part of parts) {
42 if (!tagsIndex[part]) tagsIndex[part] = { tag: part, tagfiltered: Navigation.normalize(part), items: [], children: {} };
43 if (!tagsIndex[part].items.includes(item)) tagsIndex[part].items.push(item);
44 if (lastPart) tagsIndex[lastPart].children[part] = tagsIndex[part];
45 lastPart = part;
46 }
47 }
48 }
49
50 // ---
51
52
53 public static searchTags(tagsIndex: Tag.Index, filter: string): Tag.Search[] {
54 let search: Tag.Search[] = [];
55 if (tagsIndex && filter) {
56 const operation = IndexFactory.extractOperation(filter);
57 if (operation !== Operation.INTERSECTION) filter = filter.slice(1);
58 if (filter.includes(":")) {
59 const filterParts = filter.split(":");
60 search = this.searchTagsFromFilterWithCategory(tagsIndex, operation, filterParts[0], filterParts[1]);
61 } else {
62 search = this.searchTagsFromFilter(tagsIndex, operation, filter);
63 }
64 }
65 return search;
66 }
67
68 private static extractOperation(filter: string): Operation {
69 const first = filter.slice(0, 1);
70 switch (first) {
71 case Operation.ADDITION:
72 case Operation.SUBSTRACTION:
73 return first;
74 default:
75 return Operation.INTERSECTION;
76 }
77 }
78
79 private static searchTagsFromFilterWithCategory(
80 tagsIndex: Tag.Index,
81 operation: Operation,
82 category: string,
83 disambiguation: string
84 ): Tag.Search[] {
85 disambiguation = Navigation.normalize(disambiguation);
86 return Object.values(tagsIndex)
87 .filter(node => node.tag.includes(category))
88 .flatMap(node =>
89 Object.values(node.children)
90 .filter(child => child.tagfiltered.includes(disambiguation))
91 .map(child => ({ ...child, parent: node, operation, display: `${operation}${node.tag}:${child.tag}` }))
92 );
93 }
94
95 private static searchTagsFromFilter(tagsIndex: Tag.Index, operation: Operation, filter: string): Tag.Search[] {
96 filter = Navigation.normalize(filter);
97 return Object.values(tagsIndex)
98 .filter(node => node.tagfiltered.includes(filter))
99 .map(node => ({ ...node, operation, display: `${operation}${node.tag}` }));
100 }
101}
diff --git a/viewer/src/services/indexsearch.ts b/viewer/src/services/indexsearch.ts
new file mode 100644
index 0000000..3e73fb1
--- /dev/null
+++ b/viewer/src/services/indexsearch.ts
@@ -0,0 +1,70 @@
1/* ldgallery - A static generator which turns a collection of tagged
2-- pictures into a searchable web gallery.
3--
4-- Copyright (C) 2019-2020 Guillaume FOUET
5--
6-- This program is free software: you can redistribute it and/or modify
7-- it under the terms of the GNU Affero General Public License as
8-- published by the Free Software Foundation, either version 3 of the
9-- License, or (at your option) any later version.
10--
11-- This program is distributed in the hope that it will be useful,
12-- but WITHOUT ANY WARRANTY; without even the implied warranty of
13-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14-- GNU Affero General Public License for more details.
15--
16-- You should have received a copy of the GNU Affero General Public License
17-- along with this program. If not, see <https://www.gnu.org/licenses/>.
18*/
19
20import { Operation } from '@/@types/Operation';
21
22export default class IndexSearch {
23
24 // Results of the search (by tags)
25 public static search(searchTags: Tag.Search[], rootPath: string): Gallery.Item[] {
26 const byOperation = this.extractTagsByOperation(searchTags);
27 const intersection = this.extractIntersection(byOperation);
28 const substraction = this.extractSubstraction(byOperation);
29 return this.aggregateAll(byOperation, intersection, substraction)
30 .filter(item => item.path.startsWith(rootPath));
31 }
32
33 private static extractTagsByOperation(searchTags: Tag.Search[]): Tag.SearchByOperation {
34 let byOperation: Tag.SearchByOperation = {};
35 Object.values(Operation).forEach(
36 operation => (byOperation[operation] = searchTags.filter(tag => tag.operation === operation))
37 );
38 return byOperation;
39 }
40
41 private static extractIntersection(byOperation: Tag.SearchByOperation): Set<Gallery.Item> {
42 let intersection = new Set<Gallery.Item>();
43 if (byOperation[Operation.INTERSECTION].length > 0) {
44 byOperation[Operation.INTERSECTION]
45 .map(tag => tag.items)
46 .reduce((a, b) => a.filter(c => b.includes(c)))
47 .flatMap(items => items)
48 .forEach(item => intersection.add(item));
49 }
50 return intersection;
51 }
52
53 private static extractSubstraction(byOperation: Tag.SearchByOperation): Set<Gallery.Item> {
54 let substraction = new Set<Gallery.Item>();
55 if (byOperation[Operation.SUBSTRACTION].length > 0) {
56 byOperation[Operation.SUBSTRACTION].flatMap(tag => tag.items).forEach(item => substraction.add(item));
57 }
58 return substraction;
59 }
60
61 private static aggregateAll(
62 byOperation: Tag.SearchByOperation,
63 intersection: Set<Gallery.Item>,
64 substraction: Set<Gallery.Item>
65 ): Gallery.Item[] {
66 byOperation[Operation.ADDITION].flatMap(tag => tag.items).forEach(item => intersection.add(item));
67 substraction.forEach(item => intersection.delete(item));
68 return [...intersection];