feeds-fun 1.15.0 → 1.16.0

package/src/views/NewsView.vue

@@ -15,15 +15,6 @@
     </template>
 
     <template #side-menu-item-3>
-      Show tags:
-      <config-flag
-        style="min-width: 2.5rem"
-        v-model:flag="globalSettings.showEntriesTags"
-        on-text="no"
-        off-text="yes" />
-    </template>
-
-    <template #side-menu-item-4>
       Show read:
       <config-flag
         style="min-width: 2.5rem"
@@ -35,7 +26,7 @@
     <template #side-footer>
       <tags-filter
         :tags="tagsCount"
-        @tag:stateChanged="onTagStateChanged" />
+        :show-create-rule="true" />
     </template>
 
     <template #main-header>
@@ -55,16 +46,14 @@
     <entries-list
       :entriesIds="entriesReport"
       :time-field="timeField"
-      :show-tags="globalSettings.showEntriesTags"
       :tags-count="tagsCount"
       :showFromStart="25"
-      :showPerPage="25"
-      @entry:bodyVisibilityChanged="onBodyVisibilityChanged" />
+      :showPerPage="25" />
   </side-panel-layout>
 </template>
 
 <script lang="ts" setup>
-  import {computed, ref, onUnmounted, watch} from "vue";
+  import {computed, ref, onUnmounted, watch, provide} from "vue";
   import {computedAsync} from "@vueuse/core";
   import * as api from "@/logic/api";
   import * as tagsFilterState from "@/logic/tagsFilterState";
@@ -79,67 +68,86 @@
 
   const tagsStates = ref<tagsFilterState.Storage>(new tagsFilterState.Storage());
 
+  provide("tagsStates", tagsStates);
+
   globalSettings.mainPanelMode = e.MainPanelMode.Entries;
 
   globalSettings.updateDataVersion();
 
   const entriesWithOpenedBody = ref<{[key: t.EntryId]: boolean}>({});
 
-  const entriesReport = computed(() => {
+  const _sortedEntries = computed(() => {
     if (entriesStore.loadedEntriesReport === null) {
       return [];
     }
 
-    let report = entriesStore.loadedEntriesReport.slice();
+    const orderProperties = e.EntriesOrderProperties.get(globalSettings.entriesOrder);
 
-    if (!globalSettings.showRead) {
-      report = report.filter((entryId) => {
-        if (entriesWithOpenedBody.value[entryId]) {
-          // always show read entries with open body
-          // otherwise, they will hide right after opening it
-          return true;
-        }
-        return !entriesStore.entries[entryId].hasMarker(e.Marker.Read);
-      });
+    if (orderProperties === undefined) {
+      throw new Error(`Unknown order ${globalSettings.entriesOrder}`);
     }
 
-    report = tagsStates.value.filterByTags(report, (entryId) => entriesStore.entries[entryId].tags);
-
-    report = report.sort((a: t.EntryId, b: t.EntryId) => {
-      const orderProperties = e.EntriesOrderProperties.get(globalSettings.entriesOrder);
+    const field = orderProperties.orderField;
+    const direction = orderProperties.direction;
 
-      if (orderProperties === undefined) {
-        throw new Error(`Unknown order ${globalSettings.entriesOrder}`);
-      }
+    // let report = entriesStore.loadedEntriesReport.slice();
 
-      const field = orderProperties.orderField;
-
-      const valueA = _.get(entriesStore.entries[a], field, null);
-      const valueB = _.get(entriesStore.entries[b], field, null);
+    // Pre-map to avoid repeated lookups in the comparator
+    const mapped = entriesStore.loadedEntriesReport.map((entryId) => {
+      // @ts-ignore
+      return {entryId, value: entriesStore.entries[entryId][field]};
+    });
 
-      if (valueA === null && valueB === null) {
+    mapped.sort((a: {entryId: t.EntryId; value: any}, b: {entryId: t.EntryId; value: any}) => {
+      if (a.value === null && b.value === null) {
         return 0;
       }
 
-      if (valueA === null) {
+      if (a.value === null) {
         return 1;
       }
 
-      if (valueB === null) {
+      if (b.value === null) {
         return -1;
       }
 
-      if (valueA < valueB) {
-        return orderProperties.direction;
+      if (a.value < b.value) {
+        return direction;
       }
 
-      if (valueA > valueB) {
-        return -orderProperties.direction;
+      if (a.value > b.value) {
+        return -direction;
       }
 
       return 0;
     });
 
+    const report = mapped.map((x) => x.entryId);
+
+    return report;
+  });
+
+  const _visibleEntries = computed(() => {
+    let report = _sortedEntries.value.slice();
+
+    if (!globalSettings.showRead) {
+      report = report.filter((entryId) => {
+        if (entriesStore.displayedEntryId == entryId) {
+          // always show read entries with open body
+          // otherwise, they will hide right after opening it
+          return true;
+        }
+        return !entriesStore.entries[entryId].hasMarker(e.Marker.Read);
+      });
+    }
+
+    return report;
+  });
+
+  const entriesReport = computed(() => {
+    let report = _visibleEntries.value.slice();
+
+    report = tagsStates.value.filterByTags(report, (entryId) => entriesStore.entries[entryId].tags);
     return report;
   });
 
@@ -193,14 +201,6 @@
 
     return orderProperties.timeField;
   });
-
-  function onTagStateChanged({tag, state}: {tag: string; state: tagsFilterState.State}) {
-    tagsStates.value.onTagStateChanged({tag, state});
-  }
-
-  function onBodyVisibilityChanged({entryId, visible}: {entryId: t.EntryId; visible: boolean}) {
-    entriesWithOpenedBody.value[entryId] = visible;
-  }
 </script>
 
 <style></style>

package/src/views/RulesView.vue

@@ -13,11 +13,21 @@
     </template>
 
     <template #side-footer>
-      <tags-filter
-        :tags="tags"
-        @tag:stateChanged="onTagStateChanged" />
+      <tags-filter :tags="tagsCount" />
     </template>
 
+    <div class="ffun-info-good">
+      <p
+        >You can create new rules on the
+        <a
+          href="#"
+          @click.prevent="goToNews()"
+          >news</a
+        >
+        tab.</p
+      >
+    </div>
+
     <rules-list
       v-if="rules"
       :rules="sortedRules" />
@@ -25,7 +35,8 @@
 </template>
 
 <script lang="ts" setup>
-  import {computed, ref, onUnmounted, watch} from "vue";
+  import {computed, ref, onUnmounted, watch, provide} from "vue";
+  import {useRouter} from "vue-router";
   import {computedAsync} from "@vueuse/core";
   import {useGlobalSettingsStore} from "@/stores/globalSettings";
   import _ from "lodash";
@@ -34,19 +45,28 @@
   import type * as t from "@/logic/types";
   import * as e from "@/logic/enums";
   import * as tagsFilterState from "@/logic/tagsFilterState";
+
+  const router = useRouter();
+
   const tagsStates = ref<tagsFilterState.Storage>(new tagsFilterState.Storage());
 
+  provide("tagsStates", tagsStates);
+
   const globalSettings = useGlobalSettingsStore();
 
   globalSettings.mainPanelMode = e.MainPanelMode.Rules;
 
+  function goToNews() {
+    router.push({name: e.MainPanelMode.Entries, params: {}});
+  }
+
   const rules = computedAsync(async () => {
     // force refresh
     globalSettings.dataVersion;
     return await api.getRules();
   }, null);
 
-  const tags = computed(() => {
+  const tagsCount = computed(() => {
     if (!rules.value) {
       return {};
     }
@@ -54,7 +74,11 @@
     const tags: {[key: string]: number} = {};
 
     for (const rule of rules.value) {
-      for (const tag of rule.tags) {
+      for (const tag of rule.requiredTags) {
+        tags[tag] = (tags[tag] || 0) + 1;
+      }
+
+      for (const tag of rule.excludedTags) {
         tags[tag] = (tags[tag] || 0) + 1;
       }
     }
@@ -69,7 +93,7 @@
 
     let sorted = rules.value.slice();
 
-    sorted = tagsStates.value.filterByTags(sorted, (rule) => rule.tags);
+    sorted = tagsStates.value.filterByTags(sorted, (rule) => rule.requiredTags.concat(rule.excludedTags));
 
     const orderProperties = e.RulesOrderProperties.get(globalSettings.rulesOrder);
 
@@ -86,14 +110,14 @@
 
     sorted = sorted.sort((a: t.Rule, b: t.Rule) => {
       if (globalSettings.rulesOrder === e.RulesOrder.Tags) {
-        return utils.compareLexicographically(a.tags, b.tags);
+        return utils.compareLexicographically(a.allTags, b.allTags);
       }
 
       const valueA = _.get(a, orderField, null);
       const valueB = _.get(b, orderField, null);
 
       if (valueA === null && valueB === null) {
-        return utils.compareLexicographically(a.tags, b.tags);
+        return utils.compareLexicographically(a.allTags, b.allTags);
       }
 
       if (valueA === null) {
@@ -112,13 +136,9 @@
         return -1 * direction;
       }
 
-      return utils.compareLexicographically(a.tags, b.tags);
+      return utils.compareLexicographically(a.allTags, b.allTags);
     });
 
     return sorted;
   });
-
-  function onTagStateChanged({tag, state}: {tag: string; state: tagsFilterState.State}) {
-    tagsStates.value.onTagStateChanged({tag, state});
-  }
 </script>