viewer: types normalization - tag.d.ts

GitHub: closes #301

7 files changed, 62 insertions, 56 deletions

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}` }));