6 files changed, 56 insertions, 44 deletions

diff --git a/viewer/src/services/fetchWithCheck.ts b/viewer/src/services/fetchWithCheck.ts
new file mode 100644
index 0000000..e84e8b6
--- /dev/null
+++ b/viewer/src/services/fetchWithCheck.ts
@@ -0,0 +1,7 @@
+export default class FetchWithCheck {
+  static async get(url: RequestInfo): Promise<Response> {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`${response.status}: ${response.statusText}`);
+    return response;
+  }
+}
diff --git a/viewer/src/services/indexfactory.ts b/viewer/src/services/indexfactory.ts
index 4b28a60..691a765 100644
--- a/viewer/src/services/indexfactory.ts
+++ b/viewer/src/services/indexfactory.ts
@@ -17,19 +17,21 @@
 -- along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-import { Operation } from "@/@types/Operation";
+import { Item, RawTag } from "@/@types/gallery";
 import { ItemType } from "@/@types/ItemType";
+import { Operation } from "@/@types/Operation";
+import { TagCategory, TagIndex, TagNode, TagSearch } from "@/@types/tag";
 import Navigation from "@/services/navigation";
 
 export default class IndexFactory {
-  public static generateTags(root: Gallery.Item | null): Tag.Index {
-    const tagsIndex: Tag.Index = {};
+  public static generateTags(root: Item | null): TagIndex {
+    const tagsIndex: TagIndex = {};
     if (root) IndexFactory.pushTagsForItem(tagsIndex, root);
     return tagsIndex;
   }
 
   // Pushes all tags for a root item (and its children) to the index
-  private static pushTagsForItem(tagsIndex: Tag.Index, item: Gallery.Item): void {
+  private static pushTagsForItem(tagsIndex: TagIndex, item: Item): void {
     if (item.properties.type === ItemType.DIRECTORY) {
       item.properties.items.forEach(item => this.pushTagsForItem(tagsIndex, item));
       return; // Directories are not indexed
@@ -49,7 +51,7 @@ export default class IndexFactory {
     }
   }
 
-  private static pushPartToIndex(index: Tag.Node, part: string, item: Gallery.Item, rootPart: boolean): Tag.Node {
+  private static pushPartToIndex(index: TagNode, part: string, item: Item, rootPart: boolean): TagNode {
     if (!index)
       index = {
         tag: part,
@@ -68,8 +70,8 @@ export default class IndexFactory {
 
   // ---
 
-  public static searchTags(tagsIndex: Tag.Index, filter: string, strict: boolean): Tag.Search[] {
-    let search: Tag.Search[] = [];
+  public static searchTags(tagsIndex: TagIndex, filter: string, strict: boolean): TagSearch[] {
+    let search: TagSearch[] = [];
     if (tagsIndex && filter) {
       const operation = IndexFactory.extractOperation(filter);
       if (operation !== Operation.INTERSECTION) filter = filter.slice(1);
@@ -95,12 +97,12 @@ export default class IndexFactory {
   }
 
   private static searchTagsFromFilterWithCategory(
-    tagsIndex: Tag.Index,
+    tagsIndex: TagIndex,
     operation: Operation,
     category: string,
     disambiguation: string,
     strict: boolean
-  ): Tag.Search[] {
+  ): TagSearch[] {
     category = Navigation.normalize(category);
     disambiguation = Navigation.normalize(disambiguation);
     return Object.values(tagsIndex)
@@ -113,28 +115,28 @@ export default class IndexFactory {
   }
 
   private static searchTagsFromFilter(
-    tagsIndex: Tag.Index,
+    tagsIndex: TagIndex,
     operation: Operation,
     filter: string,
     strict: boolean
-  ): Tag.Search[] {
+  ): TagSearch[] {
     filter = Navigation.normalize(filter);
     return Object.values(tagsIndex)
       .filter(node => IndexFactory.matches(node, filter, strict))
       .map(node => ({ ...node, operation, display: `${operation}${node.tag}` }));
   }
 
-  private static matches(node: Tag.Node, filter: string, strict: boolean): boolean {
+  private static matches(node: TagNode, filter: string, strict: boolean): boolean {
     if (strict) return node.tagfiltered === filter;
     return node.tagfiltered.includes(filter);
   }
 
   // ---
 
-  public static generateCategories(tagsIndex: Tag.Index, categoryTags?: Gallery.RawTag[]): Tag.Category[] {
+  public static generateCategories(tagsIndex: TagIndex, categoryTags?: RawTag[]): TagCategory[] {
     if (!categoryTags?.length) return [{ tag: "", index: tagsIndex }];
 
-    const tagsCategories: Tag.Category[] = [];
+    const tagsCategories: TagCategory[] = [];
     const tagsRemaining = new Map(Object.entries(tagsIndex));
     categoryTags
       .map(tag => ({ tag, index: tagsIndex[tag]?.children }))
@@ -149,7 +151,7 @@ export default class IndexFactory {
     return tagsCategories;
   }
 
-  private static isDiscriminantTagOnly(tags: Gallery.RawTag[], node: Tag.Node): boolean {
+  private static isDiscriminantTagOnly(tags: RawTag[], node: TagNode): boolean {
     return !tags.includes(node.tag) || !node.childPart;
   }
 }
diff --git a/viewer/src/services/indexsearch.ts b/viewer/src/services/indexsearch.ts
index 00f8cfc..57bd03c 100644
--- a/viewer/src/services/indexsearch.ts
+++ b/viewer/src/services/indexsearch.ts
@@ -17,27 +17,29 @@
 -- along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
+import { Item } from "@/@types/gallery";
 import { Operation } from "@/@types/Operation";
+import { TagSearch, TagSearchByOperation } from "@/@types/tag";
 
 export default class IndexSearch {
   // Results of the search (by tags)
-  public static search(searchTags: Tag.Search[]): Gallery.Item[] {
+  public static search(searchTags: TagSearch[]): Item[] {
     const byOperation = this.extractTagsByOperation(searchTags);
     const intersection = this.extractIntersection(byOperation);
     const substraction = this.extractSubstraction(byOperation);
     return this.aggregateAll(byOperation, intersection, substraction);
   }
 
-  private static extractTagsByOperation(searchTags: Tag.Search[]): Tag.SearchByOperation {
-    const byOperation: Tag.SearchByOperation = {};
+  private static extractTagsByOperation(searchTags: TagSearch[]): TagSearchByOperation {
+    const byOperation: TagSearchByOperation = {};
     Object.values(Operation).forEach(
       operation => (byOperation[operation] = searchTags.filter(tag => tag.operation === operation))
     );
     return byOperation;
   }
 
-  private static extractIntersection(byOperation: Tag.SearchByOperation): Set<Gallery.Item> {
-    const intersection = new Set<Gallery.Item>();
+  private static extractIntersection(byOperation: TagSearchByOperation): Set<Item> {
+    const intersection = new Set<Item>();
     if (byOperation[Operation.INTERSECTION].length > 0) {
       byOperation[Operation.INTERSECTION]
         .map(tag => tag.items)
@@ -48,8 +50,8 @@ export default class IndexSearch {
     return intersection;
   }
 
-  private static extractSubstraction(byOperation: Tag.SearchByOperation): Set<Gallery.Item> {
-    const substraction = new Set<Gallery.Item>();
+  private static extractSubstraction(byOperation: TagSearchByOperation): Set<Item> {
+    const substraction = new Set<Item>();
     if (byOperation[Operation.SUBSTRACTION].length > 0) {
       byOperation[Operation.SUBSTRACTION].flatMap(tag => tag.items).forEach(item => substraction.add(item));
     }
@@ -57,10 +59,10 @@ export default class IndexSearch {
   }
 
   private static aggregateAll(
-    byOperation: Tag.SearchByOperation,
-    intersection: Set<Gallery.Item>,
-    substraction: Set<Gallery.Item>
-  ): Gallery.Item[] {
+    byOperation: TagSearchByOperation,
+    intersection: Set<Item>,
+    substraction: Set<Item>
+  ): Item[] {
     byOperation[Operation.ADDITION].flatMap(tag => tag.items).forEach(item => intersection.add(item));
     substraction.forEach(item => intersection.delete(item));