npm-dropdown-package 1.0.0

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+declare class GenerateDropdownData {
+    featureLayers: [FeatureLayer, FeatureLayer?] | any;
+    fieldNames: [string, string?, string?] | any;
+    constructor(featureLayers: any, fieldNames: any);
+    dropDownQuery: () => Promise<any>;
+}
+export default GenerateDropdownData;

package/build/index.js

@@ -0,0 +1,401 @@
+class GenerateDropdownData {
+    constructor(featureLayers, fieldNames) {
+        // Define method
+        this.dropDownQuery = async () => {
+            // ################### One Feature Layer ################### //
+            if (this.featureLayers.length === 1) {
+                // One dropdown (= one field):-----------------------
+                if (this.fieldNames[1] === undefined &&
+                    this.fieldNames[2] === undefined) {
+                    var query11 = this.featureLayers[0].createQuery();
+                    query11.outFields = ["*"];
+                    query11.orderByFields = [this.fieldNames[0]];
+                    query11.groupByFieldsForStatistics = [this.fieldNames[0]];
+                    const pairQ = this.featureLayers[0]
+                        .queryFeatures(query11)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            return Object.assign({
+                                field1: field1,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1) ===
+                            index);
+                        return pair;
+                    });
+                    const pairs = await pairQ;
+                    // 2. Unique falues for field1
+                    const uniqueField1 = pairs
+                        .map((item) => item.field1)
+                        .filter((field1, index, emp) => emp.indexOf(field1) === index);
+                    // 3. Compile for all the fields:
+                    const field1Array = uniqueField1.map((field1, index) => {
+                        return Object.assign({
+                            field1: field1, // field1 = cp
+                        });
+                    });
+                    return field1Array;
+                    // Two dropdowns (= two fields):-----------------------
+                }
+                else if (this.fieldNames[2] === undefined) {
+                    var query12 = this.featureLayers[0].createQuery();
+                    query12.outFields = [this.fieldNames[0], this.fieldNames[1]];
+                    query12.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+                    query12.groupByFieldsForStatistics = [
+                        this.fieldNames[0],
+                        this.fieldNames[1],
+                    ];
+                    const pairQ = this.featureLayers[0]
+                        .queryFeatures(query12)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            const field2 = attributes[this.fieldNames[1]];
+                            return Object.assign({
+                                field1: field1,
+                                field2: field2,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1 && item.field2 === val.field2) === index);
+                        return pair;
+                    });
+                    const pairs = await pairQ;
+                    // 2. Unique falues for field1
+                    const uniqueField1 = pairs
+                        .map((item) => item.field1)
+                        .filter((field1, index, emp) => emp.indexOf(field1) === index);
+                    // 3. Compile for all the fields:
+                    const field1Array = uniqueField1.map((field1, index) => {
+                        const filterField1 = pairs.filter((emp) => emp.field1 === field1);
+                        const uniqueField2 = filterField1
+                            .map((item) => item.field2)
+                            .filter((field2, index, emp) => emp.indexOf(field2) === index);
+                        // 3.2. Unique values for field3 corresponding to field1 and field2
+                        // eslint-disable-next-line array-callback-return
+                        const field2Array = uniqueField2.map((field2, index) => {
+                            return Object.assign({
+                                name: field2,
+                            });
+                        });
+                        return Object.assign({
+                            field1: field1, // field1 = cp
+                            field2: field2Array, // field2 = company
+                        });
+                    });
+                    return field1Array;
+                    // Three dropdowns (= three fields):-----------------------
+                }
+                else {
+                    // 1. Pairs for 1st feature layer
+                    var query13 = this.featureLayers[0].createQuery();
+                    query13.outFields = [this.fieldNames[0], this.fieldNames[1]];
+                    query13.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+                    query13.groupByFieldsForStatistics = [
+                        this.fieldNames[0],
+                        this.fieldNames[1],
+                    ];
+                    query13.where = `${this.fieldNames[0]} IS NOT NULL`;
+                    const pairQ = this.featureLayers[0]
+                        .queryFeatures(query13)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            const field2 = attributes[this.fieldNames[1]];
+                            const field3 = attributes[this.fieldNames[2]];
+                            return Object.assign({
+                                field1: field1,
+                                field2: field2,
+                                field3: field3,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1 &&
+                            item.field2 === val.field2 &&
+                            item.field3 === val.field3) === index);
+                        return pair;
+                    });
+                    const pairs = await pairQ;
+                    // 2. Unique falues for field1
+                    const uniqueField1 = pairs
+                        .map((item) => item.field1)
+                        .filter((field1, index, emp) => emp.indexOf(field1) === index);
+                    // 3. Compile for all the fields:
+                    const field1Array = uniqueField1.map((field1, index) => {
+                        const filterField1 = pairs.filter((emp) => emp.field1 === field1);
+                        const uniqueField2 = filterField1
+                            .map((item) => item.field2)
+                            .filter((field2, index, emp) => emp.indexOf(field2) === index);
+                        // 3.2. Unique values for field3 corresponding to field1 and field2
+                        // eslint-disable-next-line array-callback-return
+                        const field2Array = uniqueField2.map((field2, index) => {
+                            const filterField2 = pairs.filter((emp) => emp.field1 === field1 && emp.field2 === field2);
+                            const uniqueField3 = filterField2
+                                .map((item) => item.field3)
+                                .filter((field3, index, emp) => emp.indexOf(field3) === index);
+                            // eslint-disable-next-line array-callback-return
+                            const field3Array = uniqueField3.map((field3, index) => {
+                                return Object.assign({
+                                    name: field3, // field3 = typeName (name?)
+                                });
+                            });
+                            return Object.assign({
+                                name: field2,
+                                field3: field3Array, // field3 = type
+                            });
+                        });
+                        return Object.assign({
+                            field1: field1, // field1 = cp
+                            field2: field2Array, // field2 = company
+                        });
+                    });
+                    return field1Array;
+                }
+                //
+                //
+                //
+                //
+                // ################### Two Feature Layers ################### //
+            }
+            else {
+                // One dropdown (= one field):-----------------------
+                if (this.fieldNames[1] === undefined &&
+                    this.fieldNames[2] === undefined) {
+                    var query21p = this.featureLayers[0].createQuery();
+                    query21p.outFields = ["*"];
+                    query21p.orderByFields = [this.fieldNames[0]];
+                    query21p.groupByFieldsForStatistics = [this.fieldNames[0]];
+                    const pairQ = this.featureLayers[0]
+                        .queryFeatures(query21p)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            return Object.assign({
+                                field1: field1,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1) ===
+                            index);
+                        return pair;
+                    });
+                    // 2. Pairs for 2nd feature layer
+                    var query21l = this.featureLayers[1].createQuery();
+                    query21l.outFields = ["*"];
+                    const pairQ2 = this.featureLayers[1]
+                        .queryFeatures(query21l)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            return Object.assign({
+                                field1: field1,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1) ===
+                            index);
+                        return pair;
+                    });
+                    // 3. Concatenate two pairs
+                    const pair1 = await pairQ;
+                    const pair2 = await pairQ2;
+                    const pairs = pair1.concat(pair2);
+                    // 2. Unique falues for field1
+                    const uniqueField1 = pairs
+                        .map((item) => item.field1)
+                        .filter((field1, index, emp) => emp.indexOf(field1) === index);
+                    // 3. Compile for all the fields:
+                    const field1Array = uniqueField1.map((field1, index) => {
+                        return Object.assign({
+                            field1: field1, // field1 = cp
+                        });
+                    });
+                    return field1Array;
+                    // Two dropdowns (= two fields):-----------------------
+                }
+                else if (this.fieldNames[2] === undefined) {
+                    var query22p = this.featureLayers[0].createQuery();
+                    query22p.outFields = ["*"];
+                    query22p.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+                    query22p.groupByFieldsForStatistics = [
+                        this.fieldNames[0],
+                        this.fieldNames[1],
+                    ];
+                    const pairQ = this.featureLayers[0]
+                        .queryFeatures(query22p)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            const field2 = attributes[this.fieldNames[1]];
+                            return Object.assign({
+                                field1: field1,
+                                field2: field2,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1 && item.field2 === val.field2) === index);
+                        return pair;
+                    });
+                    // 2. Pairs for 2nd feature layer
+                    var query22l = this.featureLayers[1].createQuery();
+                    query22l.outFields = ["*"];
+                    const pairQ2 = this.featureLayers[1]
+                        .queryFeatures(query22l)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            const field2 = attributes[this.fieldNames[1]];
+                            return Object.assign({
+                                field1: field1,
+                                field2: field2,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1 && item.field2 === val.field2) === index);
+                        return pair;
+                    });
+                    // 3. Concatenate two pairs
+                    const pair1 = await pairQ;
+                    const pair2 = await pairQ2;
+                    const pairs = pair1.concat(pair2);
+                    // 2. Unique falues for field1
+                    const uniqueField1 = pairs
+                        .map((item) => item.field1)
+                        .filter((field1, index, emp) => emp.indexOf(field1) === index);
+                    // 3. Compile for all the fields:
+                    const field1Array = uniqueField1.map((field1, index) => {
+                        const filterField1 = pairs.filter((emp) => emp.field1 === field1);
+                        const uniqueField2 = filterField1
+                            .map((item) => item.field2)
+                            .filter((field2, index, emp) => emp.indexOf(field2) === index);
+                        // 3.2. Unique values for field3 corresponding to field1 and field2
+                        // eslint-disable-next-line array-callback-return
+                        const field2Array = uniqueField2.map((field2, index) => {
+                            return Object.assign({
+                                name: field2,
+                            });
+                        });
+                        return Object.assign({
+                            field1: field1, // field1 = cp
+                            field2: field2Array, // field2 = company
+                        });
+                    });
+                    return field1Array;
+                    // Three dropdowns (= three fields):-----------------------
+                }
+                else {
+                    // 1. Pairs for 1st feature layer
+                    var query23p = this.featureLayers[0].createQuery();
+                    query23p.outFields = ["*"];
+                    query23p.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+                    query23p.groupByFieldsForStatistics = [
+                        this.fieldNames[0],
+                        this.fieldNames[1],
+                    ];
+                    const pairQ = this.featureLayers[0]
+                        .queryFeatures(query23p)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            const field2 = attributes[this.fieldNames[1]];
+                            const field3 = attributes[this.fieldNames[2]];
+                            return Object.assign({
+                                field1: field1,
+                                field2: field2,
+                                field3: field3,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1 &&
+                            item.field2 === val.field2 &&
+                            item.field3 === val.field3) === index);
+                        return pair;
+                    });
+                    // 2. Pairs for 2nd feature layer
+                    var query23l = this.featureLayers[1].createQuery();
+                    query23l.outFields = ["*"];
+                    const pairQ2 = this.featureLayers[1]
+                        .queryFeatures(query23l)
+                        .then((response) => {
+                        var stats = response.features;
+                        const values = stats.map((result, index) => {
+                            const attributes = result.attributes;
+                            const field1 = attributes[this.fieldNames[0]];
+                            const field2 = attributes[this.fieldNames[1]];
+                            const field3 = attributes[this.fieldNames[2]];
+                            return Object.assign({
+                                field1: field1,
+                                field2: field2,
+                                field3: field3,
+                            });
+                        });
+                        // 1. Get a pair
+                        const pair = values.filter((val, index) => values.findIndex((item) => item.field1 === val.field1 &&
+                            item.field2 === val.field2 &&
+                            item.field3 === val.field3) === index);
+                        return pair;
+                    });
+                    // 3. Concatenate two pairs
+                    const pair1 = await pairQ;
+                    const pair2 = await pairQ2;
+                    const pairs = pair1.concat(pair2);
+                    // 2. Unique falues for field1
+                    const uniqueField1 = pairs
+                        .map((item) => item.field1)
+                        .filter((field1, index, emp) => emp.indexOf(field1) === index);
+                    // 3. Compile for all the fields:
+                    const field1Array = uniqueField1.map((field1, index) => {
+                        const filterField1 = pairs.filter((emp) => emp.field1 === field1);
+                        const uniqueField2 = filterField1
+                            .map((item) => item.field2)
+                            .filter((field2, index, emp) => emp.indexOf(field2) === index);
+                        // 3.2. Unique values for field3 corresponding to field1 and field2
+                        // eslint-disable-next-line array-callback-return
+                        const field2Array = uniqueField2.map((field2, index) => {
+                            const filterField2 = pairs.filter((emp) => emp.field1 === field1 && emp.field2 === field2);
+                            const uniqueField3 = filterField2
+                                .map((item) => item.field3)
+                                .filter((field3, index, emp) => emp.indexOf(field3) === index);
+                            // eslint-disable-next-line array-callback-return
+                            const field3Array = uniqueField3.map((field3, index) => {
+                                return Object.assign({
+                                    name: field3, // field3 = typeName (name?)
+                                });
+                            });
+                            return Object.assign({
+                                name: field2,
+                                field3: field3Array, // field3 = type
+                            });
+                        });
+                        return Object.assign({
+                            field1: field1, // field1 = cp
+                            field2: field2Array, // field2 = company
+                        });
+                    });
+                    return field1Array;
+                }
+            }
+        }; // end of dropdown method
+        this.featureLayers = featureLayers;
+        this.fieldNames = fieldNames;
+    }
+}
+export default GenerateDropdownData;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "npm-dropdown-package",
+  "version": "1.0.0",
+  "description": "A package to create an object-array using feature layers hosted in Portal for ArcGIS for react-select dropdown",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "npx tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/railway-sector/npm-dropdown-package.git"
+  },
+  "keywords": [
+    "dropdown",
+    "react-select"
+  ],
+  "author": "Eiji Matsuzaki",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/railway-sector/npm-dropdown-package/issues"
+  },
+  "homepage": "https://github.com/railway-sector/npm-dropdown-package#readme",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+
+  "peerDependencies": {
+    "@arcgis/core": "^4.34.6"
+  }
+}

package/src/index.ts

@@ -0,0 +1,547 @@
+import FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+
+class GenerateDropdownData {
+  featureLayers: [FeatureLayer, FeatureLayer?] | any;
+  fieldNames: [string, string?, string?] | any;
+
+  constructor(featureLayers: any, fieldNames: any) {
+    this.featureLayers = featureLayers;
+    this.fieldNames = fieldNames;
+  }
+
+  // Define method
+  dropDownQuery = async () => {
+    // ################### One Feature Layer ################### //
+    if (this.featureLayers.length === 1) {
+      // One dropdown (= one field):-----------------------
+      if (
+        this.fieldNames[1] === undefined &&
+        this.fieldNames[2] === undefined
+      ) {
+        var query11 = this.featureLayers[0].createQuery();
+        query11.outFields = ["*"];
+        query11.orderByFields = [this.fieldNames[0]];
+        query11.groupByFieldsForStatistics = [this.fieldNames[0]];
+
+        const pairQ: any = this.featureLayers[0]
+          .queryFeatures(query11)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              return Object.assign({
+                field1: field1,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex((item: any) => item.field1 === val.field1) ===
+                index
+            );
+            return pair;
+          });
+
+        const pairs = await pairQ;
+
+        // 2. Unique falues for field1
+        const uniqueField1 = pairs
+          .map((item: any) => item.field1)
+          .filter(
+            (field1: any, index: any, emp: any) => emp.indexOf(field1) === index
+          );
+
+        // 3. Compile for all the fields:
+        const field1Array = uniqueField1.map((field1: any, index: number) => {
+          return Object.assign({
+            field1: field1, // field1 = cp
+          });
+        });
+        return field1Array;
+
+        // Two dropdowns (= two fields):-----------------------
+      } else if (this.fieldNames[2] === undefined) {
+        var query12 = this.featureLayers[0].createQuery();
+        query12.outFields = [this.fieldNames[0], this.fieldNames[1]];
+        query12.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+        query12.groupByFieldsForStatistics = [
+          this.fieldNames[0],
+          this.fieldNames[1],
+        ];
+
+        const pairQ: any = this.featureLayers[0]
+          .queryFeatures(query12)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              const field2 = attributes[this.fieldNames[1]];
+              return Object.assign({
+                field1: field1,
+                field2: field2,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex(
+                  (item: any) =>
+                    item.field1 === val.field1 && item.field2 === val.field2
+                ) === index
+            );
+            return pair;
+          });
+
+        const pairs = await pairQ;
+
+        // 2. Unique falues for field1
+        const uniqueField1 = pairs
+          .map((item: any) => item.field1)
+          .filter(
+            (field1: any, index: any, emp: any) => emp.indexOf(field1) === index
+          );
+
+        // 3. Compile for all the fields:
+        const field1Array = uniqueField1.map((field1: any, index: number) => {
+          const filterField1 = pairs.filter(
+            (emp: any) => emp.field1 === field1
+          );
+          const uniqueField2 = filterField1
+            .map((item: any) => item.field2)
+            .filter(
+              (field2: any, index: any, emp: any) =>
+                emp.indexOf(field2) === index
+            );
+
+          // 3.2. Unique values for field3 corresponding to field1 and field2
+          // eslint-disable-next-line array-callback-return
+          const field2Array = uniqueField2.map((field2: any, index: any) => {
+            return Object.assign({
+              name: field2,
+            });
+          });
+          return Object.assign({
+            field1: field1, // field1 = cp
+            field2: field2Array, // field2 = company
+          });
+        });
+        return field1Array;
+
+        // Three dropdowns (= three fields):-----------------------
+      } else {
+        // 1. Pairs for 1st feature layer
+        var query13 = this.featureLayers[0].createQuery();
+        query13.outFields = [this.fieldNames[0], this.fieldNames[1]];
+        query13.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+        query13.groupByFieldsForStatistics = [
+          this.fieldNames[0],
+          this.fieldNames[1],
+        ];
+        query13.where = `${this.fieldNames[0]} IS NOT NULL`;
+
+        const pairQ: any = this.featureLayers[0]
+          .queryFeatures(query13)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              const field2 = attributes[this.fieldNames[1]];
+              const field3 = attributes[this.fieldNames[2]];
+              return Object.assign({
+                field1: field1,
+                field2: field2,
+                field3: field3,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex(
+                  (item: any) =>
+                    item.field1 === val.field1 &&
+                    item.field2 === val.field2 &&
+                    item.field3 === val.field3
+                ) === index
+            );
+            return pair;
+          });
+
+        const pairs = await pairQ;
+
+        // 2. Unique falues for field1
+        const uniqueField1 = pairs
+          .map((item: any) => item.field1)
+          .filter(
+            (field1: any, index: any, emp: any) => emp.indexOf(field1) === index
+          );
+
+        // 3. Compile for all the fields:
+        const field1Array = uniqueField1.map((field1: any, index: number) => {
+          const filterField1 = pairs.filter(
+            (emp: any) => emp.field1 === field1
+          );
+          const uniqueField2 = filterField1
+            .map((item: any) => item.field2)
+            .filter(
+              (field2: any, index: any, emp: any) =>
+                emp.indexOf(field2) === index
+            );
+
+          // 3.2. Unique values for field3 corresponding to field1 and field2
+          // eslint-disable-next-line array-callback-return
+          const field2Array = uniqueField2.map((field2: any, index: any) => {
+            const filterField2 = pairs.filter(
+              (emp: any) => emp.field1 === field1 && emp.field2 === field2
+            );
+
+            const uniqueField3 = filterField2
+              .map((item: any) => item.field3)
+              .filter(
+                (field3: any, index: any, emp: any) =>
+                  emp.indexOf(field3) === index
+              );
+
+            // eslint-disable-next-line array-callback-return
+            const field3Array = uniqueField3.map((field3: any, index: any) => {
+              return Object.assign({
+                name: field3, // field3 = typeName (name?)
+              });
+            });
+
+            return Object.assign({
+              name: field2,
+              field3: field3Array, // field3 = type
+            });
+          });
+          return Object.assign({
+            field1: field1, // field1 = cp
+            field2: field2Array, // field2 = company
+          });
+        });
+        return field1Array;
+      }
+      //
+      //
+      //
+      //
+      // ################### Two Feature Layers ################### //
+    } else {
+      // One dropdown (= one field):-----------------------
+      if (
+        this.fieldNames[1] === undefined &&
+        this.fieldNames[2] === undefined
+      ) {
+        var query21p = this.featureLayers[0].createQuery();
+        query21p.outFields = ["*"];
+        query21p.orderByFields = [this.fieldNames[0]];
+        query21p.groupByFieldsForStatistics = [this.fieldNames[0]];
+
+        const pairQ: any = this.featureLayers[0]
+          .queryFeatures(query21p)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              return Object.assign({
+                field1: field1,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex((item: any) => item.field1 === val.field1) ===
+                index
+            );
+            return pair;
+          });
+
+        // 2. Pairs for 2nd feature layer
+        var query21l = this.featureLayers[1].createQuery();
+        query21l.outFields = ["*"];
+
+        const pairQ2: any = this.featureLayers[1]
+          .queryFeatures(query21l)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              return Object.assign({
+                field1: field1,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex((item: any) => item.field1 === val.field1) ===
+                index
+            );
+            return pair;
+          });
+
+        // 3. Concatenate two pairs
+        const pair1 = await pairQ;
+        const pair2 = await pairQ2;
+        const pairs = pair1.concat(pair2);
+
+        // 2. Unique falues for field1
+        const uniqueField1 = pairs
+          .map((item: any) => item.field1)
+          .filter(
+            (field1: any, index: any, emp: any) => emp.indexOf(field1) === index
+          );
+
+        // 3. Compile for all the fields:
+        const field1Array = uniqueField1.map((field1: any, index: number) => {
+          return Object.assign({
+            field1: field1, // field1 = cp
+          });
+        });
+        return field1Array;
+
+        // Two dropdowns (= two fields):-----------------------
+      } else if (this.fieldNames[2] === undefined) {
+        var query22p = this.featureLayers[0].createQuery();
+        query22p.outFields = ["*"];
+        query22p.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+        query22p.groupByFieldsForStatistics = [
+          this.fieldNames[0],
+          this.fieldNames[1],
+        ];
+
+        const pairQ: any = this.featureLayers[0]
+          .queryFeatures(query22p)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              const field2 = attributes[this.fieldNames[1]];
+              return Object.assign({
+                field1: field1,
+                field2: field2,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex(
+                  (item: any) =>
+                    item.field1 === val.field1 && item.field2 === val.field2
+                ) === index
+            );
+            return pair;
+          });
+
+        // 2. Pairs for 2nd feature layer
+        var query22l = this.featureLayers[1].createQuery();
+        query22l.outFields = ["*"];
+
+        const pairQ2: any = this.featureLayers[1]
+          .queryFeatures(query22l)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              const field2 = attributes[this.fieldNames[1]];
+              return Object.assign({
+                field1: field1,
+                field2: field2,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex(
+                  (item: any) =>
+                    item.field1 === val.field1 && item.field2 === val.field2
+                ) === index
+            );
+            return pair;
+          });
+
+        // 3. Concatenate two pairs
+        const pair1 = await pairQ;
+        const pair2 = await pairQ2;
+        const pairs = pair1.concat(pair2);
+
+        // 2. Unique falues for field1
+        const uniqueField1 = pairs
+          .map((item: any) => item.field1)
+          .filter(
+            (field1: any, index: any, emp: any) => emp.indexOf(field1) === index
+          );
+
+        // 3. Compile for all the fields:
+        const field1Array = uniqueField1.map((field1: any, index: number) => {
+          const filterField1 = pairs.filter(
+            (emp: any) => emp.field1 === field1
+          );
+          const uniqueField2 = filterField1
+            .map((item: any) => item.field2)
+            .filter(
+              (field2: any, index: any, emp: any) =>
+                emp.indexOf(field2) === index
+            );
+
+          // 3.2. Unique values for field3 corresponding to field1 and field2
+          // eslint-disable-next-line array-callback-return
+          const field2Array = uniqueField2.map((field2: any, index: any) => {
+            return Object.assign({
+              name: field2,
+            });
+          });
+          return Object.assign({
+            field1: field1, // field1 = cp
+            field2: field2Array, // field2 = company
+          });
+        });
+        return field1Array;
+
+        // Three dropdowns (= three fields):-----------------------
+      } else {
+        // 1. Pairs for 1st feature layer
+        var query23p = this.featureLayers[0].createQuery();
+        query23p.outFields = ["*"];
+        query23p.orderByFields = [this.fieldNames[0], this.fieldNames[1]];
+        query23p.groupByFieldsForStatistics = [
+          this.fieldNames[0],
+          this.fieldNames[1],
+        ];
+
+        const pairQ: any = this.featureLayers[0]
+          .queryFeatures(query23p)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              const field2 = attributes[this.fieldNames[1]];
+              const field3 = attributes[this.fieldNames[2]];
+              return Object.assign({
+                field1: field1,
+                field2: field2,
+                field3: field3,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex(
+                  (item: any) =>
+                    item.field1 === val.field1 &&
+                    item.field2 === val.field2 &&
+                    item.field3 === val.field3
+                ) === index
+            );
+            return pair;
+          });
+
+        // 2. Pairs for 2nd feature layer
+        var query23l = this.featureLayers[1].createQuery();
+        query23l.outFields = ["*"];
+
+        const pairQ2: any = this.featureLayers[1]
+          .queryFeatures(query23l)
+          .then((response: any) => {
+            var stats = response.features;
+            const values = stats.map((result: any, index: any) => {
+              const attributes = result.attributes;
+              const field1 = attributes[this.fieldNames[0]];
+              const field2 = attributes[this.fieldNames[1]];
+              const field3 = attributes[this.fieldNames[2]];
+              return Object.assign({
+                field1: field1,
+                field2: field2,
+                field3: field3,
+              });
+            });
+
+            // 1. Get a pair
+            const pair = values.filter(
+              (val: any, index: any) =>
+                values.findIndex(
+                  (item: any) =>
+                    item.field1 === val.field1 &&
+                    item.field2 === val.field2 &&
+                    item.field3 === val.field3
+                ) === index
+            );
+            return pair;
+          });
+
+        // 3. Concatenate two pairs
+        const pair1 = await pairQ;
+        const pair2 = await pairQ2;
+        const pairs = pair1.concat(pair2);
+
+        // 2. Unique falues for field1
+        const uniqueField1 = pairs
+          .map((item: any) => item.field1)
+          .filter(
+            (field1: any, index: any, emp: any) => emp.indexOf(field1) === index
+          );
+
+        // 3. Compile for all the fields:
+        const field1Array = uniqueField1.map((field1: any, index: number) => {
+          const filterField1 = pairs.filter(
+            (emp: any) => emp.field1 === field1
+          );
+          const uniqueField2 = filterField1
+            .map((item: any) => item.field2)
+            .filter(
+              (field2: any, index: any, emp: any) =>
+                emp.indexOf(field2) === index
+            );
+
+          // 3.2. Unique values for field3 corresponding to field1 and field2
+          // eslint-disable-next-line array-callback-return
+          const field2Array = uniqueField2.map((field2: any, index: any) => {
+            const filterField2 = pairs.filter(
+              (emp: any) => emp.field1 === field1 && emp.field2 === field2
+            );
+
+            const uniqueField3 = filterField2
+              .map((item: any) => item.field3)
+              .filter(
+                (field3: any, index: any, emp: any) =>
+                  emp.indexOf(field3) === index
+              );
+
+            // eslint-disable-next-line array-callback-return
+            const field3Array = uniqueField3.map((field3: any, index: any) => {
+              return Object.assign({
+                name: field3, // field3 = typeName (name?)
+              });
+            });
+
+            return Object.assign({
+              name: field2,
+              field3: field3Array, // field3 = type
+            });
+          });
+          return Object.assign({
+            field1: field1, // field1 = cp
+            field2: field2Array, // field2 = company
+          });
+        });
+        return field1Array;
+      }
+    }
+  }; // end of dropdown method
+}
+
+export default GenerateDropdownData;

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "outDir": "./build", // Or your preferred output directory
+    "rootDir": "./src", // Or the directory containing your source .ts files
+    "target": "esnext",
+    "module": "esnext",
+    "declaration": true, // Essential for generating .d.ts files
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false
+  },
+  "include": ["src/**/*.ts"], // Or the path to your source .ts files
+  "exclude": ["node_modules", "build"] // Or your output directory
+}