Improve typing

conterra · Feb 5, 2025 · 4ab3b1c · 4ab3b1c
1 parent a70589a
commit 4ab3b1c
Show file tree

Hide file tree

Showing 6 changed files with 111 additions and 107 deletions.
diff --git a/src/main/js/bundles/dn_portalitemloader/PortalItemLoaderModel.ts b/src/main/js/bundles/dn_portalitemloader/PortalItemLoaderModel.ts
@@ -15,7 +15,7 @@
 ///
 
 import { Mutable, properties } from "apprt-core/Mutable";
-import { Layout, Pagination, PortalItem, PortalType, SortByField, SpaceFilter, VisibleElements } from "./api";
+import { Layout, Pagination, PortalItem, PortalType, SortByField, SpaceFilter, VisibleElements, TypeFilter } from "./api";
 
 function defineProperties<Impl, P>(mutableDefinition: any, mutableProperties: P): Impl & Mutable<P> {
     properties(mutableDefinition, mutableProperties);
@@ -40,9 +40,9 @@ interface PortalItemLoaderModelProps {
     spaceFilters: any[],
     spaceFiltersPortal: any[],
     typeFilter: string,
-    typeFilters: any[],
-    typeFiltersPortal: any[],
-    typeFiltersCSW: any[],
+    typeFilters: TypeFilter[],
+    typeFiltersPortal: TypeFilter[],
+    typeFiltersCSW: TypeFilter[],
     sortAscending: boolean,
     sortByField: SortByField,
     sortByFields: any[],

diff --git a/src/main/js/bundles/dn_portalitemloader/api.ts b/src/main/js/bundles/dn_portalitemloader/api.ts
@@ -71,3 +71,8 @@ export interface VisibleElements {
     views: boolean,
     modified: boolean
 }
+
+export interface TypeFilter {
+    id: string,
+    title: string
+}
diff --git a/...rtalitemloader/templates/FilterWidget.vue → ...litemloader/templates/FilterWidget.ts.vue b/...rtalitemloader/templates/FilterWidget.vue → ...litemloader/templates/FilterWidget.ts.vue
@@ -159,24 +159,24 @@
         </v-toolbar>
     </div>
 </template>
-<script>
-    import { PortalType, SpaceFilter, VisibleElements } from "../api";
+<script lang="ts">
+    import type { Portal, PortalType, SpaceFilter, VisibleElements, Layout, TypeFilter } from "../api";
 
     export default {
         props: {
             i18n: {
                 type: Object,
-                default: () => {
+                default: (): any => {
                     return {};
                 }
             },
             layout: {
-                type: String,
-                default: ""
+                type: String as () => Layout,
+                default: "grid"
             },
             portals: {
                 type: Array,
-                default: () => []
+                default: (): Array<Portal> => []
             },
             authenticated: {
                 type: Boolean,
@@ -191,24 +191,24 @@
                 default: ""
             },
             selectedPortalType: {
-                type: PortalType,
+                type: String as () => PortalType,
                 default: ""
             },
             spaceFilter: {
-                type: SpaceFilter,
+                type: String as () => SpaceFilter,
                 default: "all"
             },
             spaceFilters: {
                 type: Array,
-                default: () => []
+                default: (): Array<SpaceFilter> => []
             },
             typeFilter: {
                 type: String,
-                default: () => ""
+                default: (): string => ""
             },
             typeFilters: {
                 type: Array,
-                default: () => []
+                default: (): Array<TypeFilter> => []
             },
             sortAscending: {
                 type: Boolean,
@@ -220,15 +220,15 @@
             },
             sortByFields: {
                 type: Array,
-                default: () => []
+                default: (): Array<string> => []
             },
             isMobile: {
                 type: Boolean,
                 default: false
             },
             visibleElements: {
-                type: VisibleElements,
-                default: () => {
+                type: Object as () => VisibleElements,
+                default: (): VisibleElements => {
                     return {
                         sortBy: true,
                         typeFilter: true,
@@ -241,90 +241,90 @@
                 }
             }
         },
-        data() {
+        data(): any {
             return {
                 filterVisible: false
             };
         },
         computed: {
-            allTypesSelected() {
+            allTypesSelected(): boolean {
                 return this.typeFilter.length === this.typeFilters.length;
             },
-            filterText() {
+            filterText(): string {
                 if(this.filterVisible) {
                     return this.i18n.hideFilters;
                 } else {
                     return this.i18n.showFilters;
                 }
             },
-            filterAvailable() {
+            filterAvailable(): boolean {
                 return this.authenticated ||
                     (this.typeFilters.length && this.visibleElements.typeFilter) || this.visibleElements.sortBy;
             },
             localLayout: {
-                get: function () {
+                get: function (): Layout {
                     return this.layout;
                 },
-                set: function (layout) {
+                set: function (layout: Layout): void {
                     this.$emit("update:layout", layout);
                 }
             },
             localSearchText: {
-                get: function () {
+                get: function (): string {
                     return this.searchText;
                 },
-                set: function (searchText) {
+                set: function (searchText: string): void {
                     this.$emit("update:search-text", searchText);
                 }
             },
             localPortalFilter: {
-                get: function () {
+                get: function (): string {
                     return this.portalFilter;
                 },
-                set: function (portalFilter) {
+                set: function (portalFilter: string): void {
                     this.$emit("update:portal-filter", portalFilter);
                 }
             },
             localSortByField: {
-                get: function () {
+                get: function (): string {
                     return this.sortByField;
                 },
-                set: function (sortByField) {
+                set: function (sortByField: string): void {
                     this.$emit("update:sort-by-field", sortByField);
                 }
             },
             localSortAscending: {
-                get: function () {
+                get: function (): boolean {
                     return this.sortAscending;
                 },
-                set: function (sortAscending) {
+                set: function (sortAscending: boolean): void {
                     this.$emit("update:sort-ascending", sortAscending);
                 }
             },
             localSpaceFilter: {
-                get: function () {
+                get: function (): SpaceFilter {
                     return this.spaceFilter;
                 },
-                set: function (spaceFilter) {
+                set: function (spaceFilter: SpaceFilter): void {
                     this.$emit("update:space-filter", spaceFilter);
                 }
             },
             localTypeFilter: {
-                get: function () {
+                get: function (): string {
                     return this.typeFilter;
                 },
-                set: function (typeFilter) {
+                set: function (typeFilter: string): void {
                     this.$emit("update:type-filter", typeFilter);
                 }
             }
         },
         methods: {
-            toggle () {
+            toggle(): void {
                 this.$nextTick(() => {
                     if (this.allTypesSelected) {
                         this.localTypeFilter = [];
                     } else {
-                        this.localTypeFilter = this.typeFilters.map((type)=>type.id);
+                        this.localTypeFilter = this.typeFilters.map((type: TypeFilter) => type.id);
                     }
                 });
             }

diff --git a/...portalitemloader/templates/PortalItem.vue → ...talitemloader/templates/PortalItem.ts.vue b/...portalitemloader/templates/PortalItem.vue → ...talitemloader/templates/PortalItem.ts.vue
@@ -164,7 +164,7 @@
         </v-card-actions>
     </v-card>
 </template>
-<script>
+<script lang="ts">
     import moment from 'moment';
     import * as intl from "esri/intl";
     import { PortalItem, VisibleElements } from "../api";
@@ -173,19 +173,35 @@
         props: {
             i18n: {
                 type: Object,
-                default: () => {
+                default: (): any => {
                     return {};
                 }
             },
             item: {
-                type: PortalItem,
-                default: () => {
-                    return {};
+                type: Object as () => PortalItem,
+                default: (): PortalItem => {
+                    return {
+                        id: '',
+                        title: '',
+                        snippet: '',
+                        description: '',
+                        thumbnailUrl: '',
+                        tags: [],
+                        owner: '',
+                        numViews: 0,
+                        created: new Date(),
+                        modified: new Date(),
+                        type: '',
+                        url: '',
+                        itemPageUrl: '',
+                        portalUrl: '',
+                        source: "portal"
+                    };
                 }
             },
             visibleElements: {
-                type: VisibleElements,
-                default: () => {
+                type: Object as () => VisibleElements,
+                default: (): VisibleElements => {
                     return {
                         sortBy: true,
                         typeFilter: true,
@@ -199,15 +215,15 @@
             }
         },
         computed: {
-            modified() {
+            modified(): string | undefined {
                 const modified = moment(this.item.modified);
                 if(modified.isValid()) {
                     return moment(modified).format("DD.MM.YYYY");
                 } else {
                     return undefined;
                 }
             },
-            views() {
+            views(): string {
                 const numberFormatIntlOptions = intl.convertNumberFormatToIntlOptions({
                     digitSeparator: true
                 });