From 92cb34b719b481faf417760f307241e8f6d777a9 Mon Sep 17 00:00:00 2001
From: Zero~Informatique
Date: Fri, 2 Jul 2021 22:59:56 +0200
Subject: viewer: types normalization - tag.d.ts

GitHub: closes #301
---
 viewer/src/@types/tag.d.ts              | 40 ++++++++++++++++-----------------
 viewer/src/components/LdProposition.vue |  9 ++++----
 viewer/src/components/LdTagInput.vue    | 11 ++++-----
 viewer/src/services/indexfactory.ts     | 29 ++++++++++++------------
 viewer/src/services/indexsearch.ts      | 13 ++++++-----
 viewer/src/store/galleryStore.ts        | 13 ++++++-----
 viewer/src/views/PanelLeft.vue          |  3 ++-
 7 files changed, 62 insertions(+), 56 deletions(-)

(limited to 'viewer')

diff --git a/viewer/src/@types/tag.d.ts b/viewer/src/@types/tag.d.ts
index bb908d3..9ed2c04 100644
--- a/viewer/src/@types/tag.d.ts
+++ b/viewer/src/@types/tag.d.ts
@@ -17,25 +17,25 @@
 -- along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-declare namespace Tag {
-  interface Node {
-    tag: RawTag;
-    tagfiltered: RawTag;
-    rootPart: boolean;
-    childPart: boolean;
-    items: Item[];
-    children: Index;
-  }
-  interface Search extends Node {
-    parent?: Node;
-    operation: string; // Enum Operation
-    display: string;
-  }
-  type SearchByOperation = Record<string, Tag.Search[]>;
-  type Index = Record<string, Node>;
+import { Item, RawTag } from "./gallery";
 
-  interface Category {
-    tag: string;
-    index: Index;
-  }
+export interface TagNode {
+  tag: RawTag;
+  tagfiltered: RawTag;
+  rootPart: boolean;
+  childPart: boolean;
+  items: Item[];
+  children: TagIndex;
+}
+export interface TagSearch extends TagNode {
+  parent?: TagNode;
+  operation: string; // Enum Operation
+  display: string;
+}
+export type TagSearchByOperation = Record<string, TagSearch[]>;
+export type TagIndex = Record<string, TagNode>;
+
+export interface TagCategory {
+  tag: string;
+  index: TagIndex;
 }
diff --git a/viewer/src/components/LdProposition.vue b/viewer/src/components/LdProposition.vue
index 2396d1f..088e249 100644
--- a/viewer/src/components/LdProposition.vue
+++ b/viewer/src/components/LdProposition.vue
@@ -56,15 +56,16 @@
 <script lang="ts">
 import { Item, RawTag } from "@/@types/gallery";
 import { Operation } from "@/@types/Operation";
+import { TagIndex, TagNode, TagSearch } from "@/@types/tag";
 import { Component, Prop, PropSync, Vue, Watch } from "vue-property-decorator";
 
 @Component
 export default class LdProposition extends Vue {
-  @Prop() readonly category?: Tag.Node;
+  @Prop() readonly category?: TagNode;
   @Prop({ type: Boolean, required: true }) readonly showCategory!: boolean;
   @Prop({ type: Array, required: true }) readonly currentTags!: string[];
-  @Prop({ required: true }) readonly tagsIndex!: Tag.Index;
-  @PropSync("searchFilters", { type: Array, required: true }) model!: Tag.Search[];
+  @Prop({ required: true }) readonly tagsIndex!: TagIndex;
+  @PropSync("searchFilters", { type: Array, required: true }) model!: TagSearch[];
 
   readonly INITIAL_TAG_DISPLAY_LIMIT = this.getInitialTagDisplayLimit();
 
@@ -119,7 +120,7 @@ export default class LdProposition extends Vue {
     return this.category?.tag ?? this.$t("panelLeft.propositions.other");
   }
 
-  extractDistinctItems(currentTags: Tag.Search[]): Item[] {
+  extractDistinctItems(currentTags: TagSearch[]): Item[] {
     return [...new Set(currentTags.flatMap(tag => tag.items))];
   }
 
diff --git a/viewer/src/components/LdTagInput.vue b/viewer/src/components/LdTagInput.vue
index ef585f0..855813a 100644
--- a/viewer/src/components/LdTagInput.vue
+++ b/viewer/src/components/LdTagInput.vue
@@ -40,22 +40,23 @@
 </template>
 
 <script lang="ts">
+import { TagIndex, TagSearch } from "@/@types/tag";
 import IndexFactory from "@/services/indexfactory";
 import { Component, Emit, Prop, PropSync, Vue } from "vue-property-decorator";
 
 @Component
 export default class LdTagInput extends Vue {
-  @Prop({ required: true }) readonly tagsIndex!: Tag.Index;
-  @PropSync("searchFilters", { type: Array, required: true }) model!: Tag.Search[];
+  @Prop({ required: true }) readonly tagsIndex!: TagIndex;
+  @PropSync("searchFilters", { type: Array, required: true }) model!: TagSearch[];
 
   currentFilter: string = "";
-  filteredTags: Tag.Search[] = [];
+  filteredTags: TagSearch[] = [];
 
-  displayOption(option: Tag.Search): string {
+  displayOption(option: TagSearch): string {
     return `${option.display} (${option.items.length})`;
   }
 
-  filterAlreadyPresent(newSearch: Tag.Search) {
+  filterAlreadyPresent(newSearch: TagSearch) {
     return !this.model.find(
       currentSearch =>
         currentSearch.tag === newSearch.tag && (!currentSearch.parent || currentSearch.parent === newSearch.parent)
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 @@
 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: 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: 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
@@ -50,7 +51,7 @@ export default class IndexFactory {
     }
   }
 
-  private static pushPartToIndex(index: Tag.Node, part: string, item: Item, rootPart: boolean): Tag.Node {
+  private static pushPartToIndex(index: TagNode, part: string, item: Item, rootPart: boolean): TagNode {
     if (!index)
       index = {
         tag: part,
@@ -69,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);
@@ -96,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)
@@ -114,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?: 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 }))
@@ -150,7 +151,7 @@ export default class IndexFactory {
     return tagsCategories;
   }
 
-  private static isDiscriminantTagOnly(tags: 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 eda1b27..57bd03c 100644
--- a/viewer/src/services/indexsearch.ts
+++ b/viewer/src/services/indexsearch.ts
@@ -19,25 +19,26 @@
 
 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[]): 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<Item> {
+  private static extractIntersection(byOperation: TagSearchByOperation): Set<Item> {
     const intersection = new Set<Item>();
     if (byOperation[Operation.INTERSECTION].length > 0) {
       byOperation[Operation.INTERSECTION]
@@ -49,7 +50,7 @@ export default class IndexSearch {
     return intersection;
   }
 
-  private static extractSubstraction(byOperation: Tag.SearchByOperation): Set<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));
@@ -58,7 +59,7 @@ export default class IndexSearch {
   }
 
   private static aggregateAll(
-    byOperation: Tag.SearchByOperation,
+    byOperation: TagSearchByOperation,
     intersection: Set<Item>,
     substraction: Set<Item>
   ): Item[] {
diff --git a/viewer/src/store/galleryStore.ts b/viewer/src/store/galleryStore.ts
index 3ef2036..e2adf18 100644
--- a/viewer/src/store/galleryStore.ts
+++ b/viewer/src/store/galleryStore.ts
@@ -18,6 +18,7 @@
 */
 
 import { Config, Index, Item } from "@/@types/gallery";
+import { TagCategory, TagIndex, TagSearch } from "@/@types/tag";
 import IndexFactory from "@/services/indexfactory";
 import Navigation from "@/services/navigation";
 import { action, createModule, mutation } from "vuex-class-component";
@@ -30,10 +31,10 @@ const VuexModule = createModule({
 export default class GalleryStore extends VuexModule {
   config: Config | null = null;
   galleryIndex: Index | null = null;
-  tagsIndex: Tag.Index = {};
-  tagsCategories: Tag.Category[] = [];
+  tagsIndex: TagIndex = {};
+  tagsCategories: TagCategory[] = [];
   currentPath: string | null = null;
-  currentSearch: Tag.Search[] = [];
+  currentSearch: TagSearch[] = [];
 
   // ---
 
@@ -45,11 +46,11 @@ export default class GalleryStore extends VuexModule {
     this.galleryIndex = Object.freeze(galleryIndex);
   }
 
-  @mutation private setTagsIndex(tagsIndex: Tag.Index) {
+  @mutation private setTagsIndex(tagsIndex: TagIndex) {
     this.tagsIndex = Object.freeze(tagsIndex);
   }
 
-  @mutation private setTagsCategories(tagsCategories: Tag.Category[]) {
+  @mutation private setTagsCategories(tagsCategories: TagCategory[]) {
     this.tagsCategories = tagsCategories;
   }
 
@@ -57,7 +58,7 @@ export default class GalleryStore extends VuexModule {
     this.currentPath = currentPath;
   }
 
-  @mutation setCurrentSearch(currentSearch: Tag.Search[]) {
+  @mutation setCurrentSearch(currentSearch: TagSearch[]) {
     this.currentSearch = currentSearch;
   }
 
diff --git a/viewer/src/views/PanelLeft.vue b/viewer/src/views/PanelLeft.vue
index 5c42fa9..ea61865 100644
--- a/viewer/src/views/PanelLeft.vue
+++ b/viewer/src/views/PanelLeft.vue
@@ -48,13 +48,14 @@
 </template>
 
 <script lang="ts">
+import { TagSearch } from "@/@types/tag";
 import Navigation from "@/services/navigation";
 import { Component, Vue, Watch } from "vue-property-decorator";
 import { Dictionary, Route } from "vue-router/types/router";
 
 @Component
 export default class PanelLeft extends Vue {
-  searchFilters: Tag.Search[] = [];
+  searchFilters: TagSearch[] = [];
   infoOpen: boolean = true;
 
   mounted() {
-- 
cgit v1.2.3