fixed typo on interface name + mapped new property for dealing with api default values

Author: brunovieira97

src/handler/HandlerInterfaces.ts

@@ -22,6 +22,7 @@ export interface IProjectMetadata {
     pickSteps: IStep[];
     defaults: IDefaultProjectData;
     parentFolder?: ParentFolder;
+    enableSmartDefaults?: boolean;
 }
 
 export interface IDefaultProjectData {
@@ -37,6 +38,7 @@ export interface IDefaultProjectData {
 export interface IHandlerItem<T extends Identifiable> extends QuickPickItem {
     label: string;
     value?: T;
+    default?: boolean;
 }
 
 export interface IPickMetadata<T extends Identifiable> {

src/model/Metadata.ts

@@ -13,7 +13,7 @@ export interface Metadata {
     type: Category<ProjectType>;
 }
 
-export enum MatadataType {
+export enum MetadataType {
     BOOTVERSION,
     JAVAVERSION,
     LANGUAGE,

src/model/ServiceManager.ts

@@ -6,7 +6,7 @@ import { IDependency, IStarters } from ".";
 import { IHandlerItem } from "../handler/HandlerInterfaces";
 import { downloadFile } from "../Utils";
 import { matchRange } from "../Utils/VersionHelper";
-import { DependencyGroup, Identifiable, MatadataType, Metadata } from "./Metadata";
+import { DependencyGroup, Identifiable, MetadataType, Metadata } from "./Metadata";
 
 /**
  * Prefer v2.2 and fallback to v2.1
@@ -17,44 +17,57 @@ const METADATA_HEADERS = { Accept: "application/vnd.initializr.v2.2+json,applica
 class ServiceManager {
     private metadataMap: Map<string, Metadata> = new Map();
 
-    public async getItems<T extends Identifiable>(serviceUrl: string, type: MatadataType): Promise<Array<IHandlerItem<T>>> {
+    public async getItems<T extends Identifiable>(serviceUrl: string, type: MetadataType): Promise<Array<IHandlerItem<T>>> {
         const metadata = await this.ensureMetadata(serviceUrl);
         if (!metadata) {
             throw new Error("Failed to fetch metadata.");
         }
         let defaultLabel: string;
         let values: any[];
         switch (type) {
-            case MatadataType.BOOTVERSION:
+            case MetadataType.BOOTVERSION:
                 defaultLabel = metadata.bootVersion.default;
                 values = metadata.bootVersion.values;
                 break;
-            case MatadataType.JAVAVERSION:
+            case MetadataType.JAVAVERSION:
                 defaultLabel = metadata.javaVersion.default;
                 values = metadata.javaVersion.values;
                 break;
-            case MatadataType.LANGUAGE:
+            case MetadataType.LANGUAGE:
                 defaultLabel = metadata.language.default;
                 values = metadata.language.values;
                 break;
-            case MatadataType.PACKAGING:
+            case MetadataType.PACKAGING:
                 defaultLabel = metadata.packaging.default;
                 values = metadata.packaging.values;
                 break;
             default:
                 throw new Error("Invalid metadata type.");
         }
 
-        const sortedValues = values.filter(x => x.id === defaultLabel).concat(values.filter(x => x.id !== defaultLabel));
+        const defaultValues = values.filter(x => x.id === defaultLabel);
+        const nonDefaultValues = values.filter(x => x.id !== defaultLabel);
+
+        let mappedDefault: Array<IHandlerItem<T>> = this.mapValues(defaultValues, type, true);
+        let mappedNonDefault: Array<IHandlerItem<T>> = this.mapValues(nonDefaultValues, type, false);
+
+        return mappedDefault.concat(mappedNonDefault);
+    }
+
+    private mapValues<T extends Identifiable>(
+        items: any[],
+        type: MetadataType,
+        isDefault: boolean
+    ): Array<IHandlerItem<T>> {
         switch (type) {
-            case MatadataType.BOOTVERSION:
-                return sortedValues.map(v => ({ value: v, label: v.name }));
-            case MatadataType.JAVAVERSION:
-                return sortedValues.map(v => ({ value: v, label: v.name }));
+            case MetadataType.BOOTVERSION:
+                return items.map(v => ({ value: v, label: v.name, default: isDefault}))
+            case MetadataType.JAVAVERSION:
+                return items.map(v => ({ value: v, label: v.name, default: isDefault }));
             default:
-                return sortedValues.map(v => ({ label: v.name }));
+                return items.map(v => ({ label: v.name, default: isDefault }));
         }
-    }
+    } 
 
     public async getAvailableDependencies(serviceUrl: string, bootVersion: string): Promise<IDependency[]> {
         const metadata = await this.ensureMetadata(serviceUrl);