Merge pull request #223 from Geode-solutions/next

Next

Author: JulienChampagnol

.github/workflows/Branch-protection.yml

@@ -0,0 +1,11 @@
+name: Pull request
+
+on:
+  pull_request:
+    types: [opened, reopened]
+    branches:
+      - master
+
+jobs:
+  update-branch:
+    uses: Geode-solutions/actions/.github/workflows/update-branch.yml@master

.github/workflows/CICD.yml

@@ -0,0 +1,14 @@
+name: Test
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - next
+
+jobs:
+  test:
+    uses: Geode-solutions/actions/.github/workflows/js-test.yml@master
+    with:
+      repos: ${{ vars.REPOS }}
+    secrets: inherit

.github/workflows/pr_update.yml

@@ -0,0 +1,12 @@
+name: Test PR
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  test:
+    uses: Geode-solutions/actions/.github/workflows/js-test-pr.yml@master
+    with:
+      repos: ${{ vars.REPOS }}
+    secrets: inherit

.github/workflows/prepare_pr.yml

@@ -0,0 +1,11 @@
+{
+  "categories": {
+    "correctness": "error",
+    "suspicious": "error",
+    "pedantic": "warn",
+    "perf": "error",
+    "style": "error",
+    "restriction": "error"
+  },
+  "plugins": ["import", "node", "oxc", "promise", "unicorn", "vitest"]
+}

.github/workflows/test.yml

@@ -6,7 +6,6 @@
   plugins: [
     '@semantic-release/commit-analyzer', 
     '@semantic-release/release-notes-generator', 
-    '@semantic-release/github',
-    '@semantic-release/npm'
+    '@semantic-release/github'
   ]
 }

.github/workflows/test_pr.yml

@@ -0,0 +1,16 @@
+export default {
+  extends: ["@commitlint/config-angular"],
+  rules: {
+    "scope-empty": [2, "never"],
+    "subject-empty": [2, "never"],
+    "subject-max-length": [0],
+    "body-leading-blank": [0],
+    "footer-leading-blank": [0],
+    "header-max-length": [0],
+    "scope-case": [0],
+    "subject-case": [0],
+    "subject-full-stop": [0],
+    "type-case": [0],
+    "type-empty": [0],
+  },
+}

.oxlintrc.json

@@ -24,7 +24,7 @@
               <v-img
                 :src="geode_objects[key].image"
                 cover
-                :class="!value['is_loadable'] ? 'disabled' : ''"
+                :class="!value['is_loadable'] ? 'disabled' : undefined"
               />
             </v-card>
           </span>
@@ -66,44 +66,81 @@
   const allowed_objects = ref({})
   const toggle_loading = useToggle(loading)
 
+  function select_geode_object(object_map) {
+    const object_keys = Object.keys(object_map)
+    if (!object_keys.length) {
+      return undefined
+    }
+    if (
+      object_keys.length === 1 &&
+      object_map[object_keys[0]].is_loadable > 0
+    ) {
+      return object_keys[0]
+    }
+    const highest_load_score = Math.max(
+      ...object_keys.map((key) => object_map[key].is_loadable),
+    )
+    if (highest_load_score <= 0) {
+      return undefined
+    }
+    const best_score_objects = object_keys.filter(
+      (key) => object_map[key].is_loadable === highest_load_score,
+    )
+    if (best_score_objects.length === 1) {
+      return best_score_objects[0]
+    }
+    const highest_priority = Math.max(
+      ...best_score_objects.map(
+        (key) => object_map[key].object_priority ?? -Infinity,
+      ),
+    )
+    const best_priority_objects = best_score_objects.filter(
+      (key) => object_map[key].object_priority === highest_priority,
+    )
+    if (highest_priority !== -Infinity && best_priority_objects.length === 1) {
+      return best_priority_objects[0]
+    }
+    return undefined
+  }
+
   async function get_allowed_objects() {
     toggle_loading()
     allowed_objects.value = {}
-    var promise_array = []
-    for (const filename of filenames) {
+    const promise_array = filenames.map((filename) => {
       const params = { filename, supported_feature }
-      const promise = api_fetch({ schema, params })
-      promise_array.push(promise)
-    }
+      return api_fetch({ schema, params })
+    })
     const responses = await Promise.all(promise_array)
-    let values = []
-    for (const response of responses) {
-      values.push(response.data.value.allowed_objects)
-    }
-    const all_keys = [...new Set(values.flatMap((value) => Object.keys(value)))]
-    const common_keys = all_keys.filter(
-      (i) => !values.some((j) => !Object.keys(j).includes(i)),
+    const allowed_objects_list = responses.map(
+      (response) => response.data.value.allowed_objects,
+    )
+    const all_keys = [...new Set(allowed_objects_list.flatMap(Object.keys))]
+    const common_keys = all_keys.filter((key) =>
+      allowed_objects_list.every((obj) => key in obj),
     )
-    var final_object = {}
+    const final_object = {}
     for (const key of common_keys) {
-      for (const value of values) {
-        if (value[key].is_loadable == false) {
-          final_object[key] = { is_loadable: false }
-        } else {
-          final_object[key] = { is_loadable: true }
-        }
+      const load_scores = allowed_objects_list.map(
+        (obj) => obj[key].is_loadable,
+      )
+      const priorities = allowed_objects_list
+        .map((obj) => obj[key].object_priority)
+        .filter((p) => p !== undefined && p !== null)
+      final_object[key] = { is_loadable: Math.min(...load_scores) }
+      if (priorities.length) {
+        final_object[key].object_priority = Math.max(...priorities)
       }
     }
-
     allowed_objects.value = final_object
-    if (Object.keys(allowed_objects.value).length == 1) {
-      set_geode_object(Object.keys(allowed_objects.value)[0])
+    const selected_object = select_geode_object(final_object)
+    if (selected_object) {
+      set_geode_object(selected_object)
     }
     toggle_loading()
   }
 
   function set_geode_object(input_geode_object) {
-    if (input_geode_object != "") {
+    if (input_geode_object) {
       emit("update_values", { input_geode_object })
       emit("increment_step")
     }