aboutsummaryrefslogtreecommitdiff
path: root/viewer/src/services
diff options
context:
space:
mode:
Diffstat (limited to 'viewer/src/services')
-rw-r--r--viewer/src/services/indexfactory.ts29
-rw-r--r--viewer/src/services/indexsearch.ts13
2 files changed, 22 insertions, 20 deletions
diff --git a/viewer/src/services/indexfactory.ts b/viewer/src/services/indexfactory.ts
index 0c5fdc5..691a765 100644
--- a/viewer/src/services/indexfactory.ts
+++ b/viewer/src/services/indexfactory.ts
@@ -20,17 +20,18 @@
20import { Item, RawTag } from "@/@types/gallery"; 20import { Item, RawTag } from "@/@types/gallery";
21import { ItemType } from "@/@types/ItemType"; 21import { ItemType } from "@/@types/ItemType";
22import { Operation } from "@/@types/Operation"; 22import { Operation } from "@/@types/Operation";
23import { TagCategory, TagIndex, TagNode, TagSearch } from "@/@types/tag";
23import Navigation from "@/services/navigation"; 24import Navigation from "@/services/navigation";
24 25
25export default class IndexFactory { 26export default class IndexFactory {
26 public static generateTags(root: Item | null): Tag.Index { 27 public static generateTags(root: Item | null): TagIndex {
27 const tagsIndex: Tag.Index = {}; 28 const tagsIndex: TagIndex = {};
28 if (root) IndexFactory.pushTagsForItem(tagsIndex, root); 29 if (root) IndexFactory.pushTagsForItem(tagsIndex, root);
29 return tagsIndex; 30 return tagsIndex;
30 } 31 }
31 32
32 // Pushes all tags for a root item (and its children) to the index 33 // Pushes all tags for a root item (and its children) to the index
33 private static pushTagsForItem(tagsIndex: Tag.Index, item: Item): void { 34 private static pushTagsForItem(tagsIndex: TagIndex, item: Item): void {
34 if (item.properties.type === ItemType.DIRECTORY) { 35 if (item.properties.type === ItemType.DIRECTORY) {
35 item.properties.items.forEach(item => this.pushTagsForItem(tagsIndex, item)); 36 item.properties.items.forEach(item => this.pushTagsForItem(tagsIndex, item));
36 return; // Directories are not indexed 37 return; // Directories are not indexed
@@ -50,7 +51,7 @@ export default class IndexFactory {
50 } 51 }
51 } 52 }
52 53
53 private static pushPartToIndex(index: Tag.Node, part: string, item: Item, rootPart: boolean): Tag.Node { 54 private static pushPartToIndex(index: TagNode, part: string, item: Item, rootPart: boolean): TagNode {
54 if (!index) 55 if (!index)
55 index = { 56 index = {
56 tag: part, 57 tag: part,
@@ -69,8 +70,8 @@ export default class IndexFactory {
69 70
70 // --- 71 // ---
71 72
72 public static searchTags(tagsIndex: Tag.Index, filter: string, strict: boolean): Tag.Search[] { 73 public static searchTags(tagsIndex: TagIndex, filter: string, strict: boolean): TagSearch[] {
73 let search: Tag.Search[] = []; 74 let search: TagSearch[] = [];
74 if (tagsIndex && filter) { 75 if (tagsIndex && filter) {
75 const operation = IndexFactory.extractOperation(filter); 76 const operation = IndexFactory.extractOperation(filter);
76 if (operation !== Operation.INTERSECTION) filter = filter.slice(1); 77 if (operation !== Operation.INTERSECTION) filter = filter.slice(1);
@@ -96,12 +97,12 @@ export default class IndexFactory {
96 } 97 }
97 98
98 private static searchTagsFromFilterWithCategory( 99 private static searchTagsFromFilterWithCategory(
99 tagsIndex: Tag.Index, 100 tagsIndex: TagIndex,
100 operation: Operation, 101 operation: Operation,
101 category: string, 102 category: string,
102 disambiguation: string, 103 disambiguation: string,
103 strict: boolean 104 strict: boolean
104 ): Tag.Search[] { 105 ): TagSearch[] {
105 category = Navigation.normalize(category); 106 category = Navigation.normalize(category);
106 disambiguation = Navigation.normalize(disambiguation); 107 disambiguation = Navigation.normalize(disambiguation);
107 return Object.values(tagsIndex) 108 return Object.values(tagsIndex)
@@ -114,28 +115,28 @@ export default class IndexFactory {
114 } 115 }
115 116
116 private static searchTagsFromFilter( 117 private static searchTagsFromFilter(
117 tagsIndex: Tag.Index, 118 tagsIndex: TagIndex,
118 operation: Operation, 119 operation: Operation,
119 filter: string, 120 filter: string,
120 strict: boolean 121 strict: boolean
121 ): Tag.Search[] { 122 ): TagSearch[] {
122 filter = Navigation.normalize(filter); 123 filter = Navigation.normalize(filter);
123 return Object.values(tagsIndex) 124 return Object.values(tagsIndex)
124 .filter(node => IndexFactory.matches(node, filter, strict)) 125 .filter(node => IndexFactory.matches(node, filter, strict))
125 .map(node => ({ ...node, operation, display: `${operation}${node.tag}` })); 126 .map(node => ({ ...node, operation, display: `${operation}${node.tag}` }));
126 } 127 }
127 128
128 private static matches(node: Tag.Node, filter: string, strict: boolean): boolean { 129 private static matches(node: TagNode, filter: string, strict: boolean): boolean {
129 if (strict) return node.tagfiltered === filter; 130 if (strict) return node.tagfiltered === filter;
130 return node.tagfiltered.includes(filter); 131 return node.tagfiltered.includes(filter);
131 } 132 }
132 133
133 // --- 134 // ---
134 135
135 public static generateCategories(tagsIndex: Tag.Index, categoryTags?: RawTag[]): Tag.Category[] { 136 public static generateCategories(tagsIndex: TagIndex, categoryTags?: RawTag[]): TagCategory[] {
136 if (!categoryTags?.length) return [{ tag: "", index: tagsIndex }]; 137 if (!categoryTags?.length) return [{ tag: "", index: tagsIndex }];
137 138
138 const tagsCategories: Tag.Category[] = []; 139 const tagsCategories: TagCategory[] = [];
139 const tagsRemaining = new Map(Object.entries(tagsIndex)); 140 const tagsRemaining = new Map(Object.entries(tagsIndex));
140 categoryTags 141 categoryTags
141 .map(tag => ({ tag, index: tagsIndex[tag]?.children })) 142 .map(tag => ({ tag, index: tagsIndex[tag]?.children }))
@@ -150,7 +151,7 @@ export default class IndexFactory {
150 return tagsCategories; 151 return tagsCategories;
151 } 152 }
152 153
153 private static isDiscriminantTagOnly(tags: RawTag[], node: Tag.Node): boolean { 154 private static isDiscriminantTagOnly(tags: RawTag[], node: TagNode): boolean {
154 return !tags.includes(node.tag) || !node.childPart; 155 return !tags.includes(node.tag) || !node.childPart;
155 } 156 }
156} 157}
diff --git a/viewer/src/services/indexsearch.ts b/viewer/src/services/indexsearch.ts
index eda1b27..57bd03c 100644
--- a/viewer/src/services/indexsearch.ts
+++ b/viewer/src/services/indexsearch.ts
@@ -19,25 +19,26 @@
19 19
20import { Item } from "@/@types/gallery"; 20import { Item } from "@/@types/gallery";
21import { Operation } from "@/@types/Operation"; 21import { Operation } from "@/@types/Operation";
22import { TagSearch, TagSearchByOperation } from "@/@types/tag";
22 23
23export default class IndexSearch { 24export default class IndexSearch {
24 // Results of the search (by tags) 25 // Results of the search (by tags)
25 public static search(searchTags: Tag.Search[]): Item[] { 26 public static search(searchTags: TagSearch[]): Item[] {
26 const byOperation = this.extractTagsByOperation(searchTags); 27 const byOperation = this.extractTagsByOperation(searchTags);
27 const intersection = this.extractIntersection(byOperation); 28 const intersection = this.extractIntersection(byOperation);
28 const substraction = this.extractSubstraction(byOperation); 29 const substraction = this.extractSubstraction(byOperation);
29 return this.aggregateAll(byOperation, intersection, substraction); 30 return this.aggregateAll(byOperation, intersection, substraction);
30 } 31 }
31 32
32 private static extractTagsByOperation(searchTags: Tag.Search[]): Tag.SearchByOperation { 33 private static extractTagsByOperation(searchTags: TagSearch[]): TagSearchByOperation {
33 const byOperation: Tag.SearchByOperation = {}; 34 const byOperation: TagSearchByOperation = {};
34 Object.values(Operation).forEach( 35 Object.values(Operation).forEach(
35 operation => (byOperation[operation] = searchTags.filter(tag => tag.operation === operation)) 36 operation => (byOperation[operation] = searchTags.filter(tag => tag.operation === operation))
36 ); 37 );
37 return byOperation; 38 return byOperation;
38 } 39 }
39 40
40 private static extractIntersection(byOperation: Tag.SearchByOperation): Set<Item> { 41 private static extractIntersection(byOperation: TagSearchByOperation): Set<Item> {
41 const intersection = new Set<Item>(); 42 const intersection = new Set<Item>();
42 if (byOperation[Operation.INTERSECTION].length > 0) { 43 if (byOperation[Operation.INTERSECTION].length > 0) {
43 byOperation[Operation.INTERSECTION] 44 byOperation[Operation.INTERSECTION]
@@ -49,7 +50,7 @@ export default class IndexSearch {
49 return intersection; 50 return intersection;
50 } 51 }
51 52
52 private static extractSubstraction(byOperation: Tag.SearchByOperation): Set<Item> { 53 private static extractSubstraction(byOperation: TagSearchByOperation): Set<Item> {
53 const substraction = new Set<Item>(); 54 const substraction = new Set<Item>();
54 if (byOperation[Operation.SUBSTRACTION].length > 0) { 55 if (byOperation[Operation.SUBSTRACTION].length > 0) {
55 byOperation[Operation.SUBSTRACTION].flatMap(tag => tag.items).forEach(item => substraction.add(item)); 56 byOperation[Operation.SUBSTRACTION].flatMap(tag => tag.items).forEach(item => substraction.add(item));
@@ -58,7 +59,7 @@ export default class IndexSearch {
58 } 59 }
59 60
60 private static aggregateAll( 61 private static aggregateAll(
61 byOperation: Tag.SearchByOperation, 62 byOperation: TagSearchByOperation,
62 intersection: Set<Item>, 63 intersection: Set<Item>,
63 substraction: Set<Item> 64 substraction: Set<Item>
64 ): Item[] { 65 ): Item[] {