feeds-fun 1.14.2 → 1.16.0

package/src/logic/types.ts

@@ -231,7 +231,9 @@ export function entryFromJSON(
 
 export type Rule = {
   readonly id: RuleId;
-  readonly tags: string[];
+  readonly requiredTags: string[];
+  readonly excludedTags: string[];
+  readonly allTags: string[];
   readonly score: number;
   readonly createdAt: Date;
   readonly updatedAt: Date;
@@ -239,22 +241,27 @@ export type Rule = {
 
 export function ruleFromJSON({
   id,
-  tags,
+  requiredTags,
+  excludedTags,
   score,
   createdAt,
   updatedAt
 }: {
   id: string;
-  tags: string[];
+  requiredTags: string[];
+  excludedTags: string[];
   score: number;
   createdAt: string;
   updatedAt: string;
 }): Rule {
-  tags = tags.sort();
+  requiredTags = requiredTags.sort();
+  excludedTags = excludedTags.sort();
 
   return {
     id: toRuleId(id),
-    tags: tags,
+    requiredTags: requiredTags,
+    excludedTags: excludedTags,
+    allTags: requiredTags.concat(excludedTags),
     score: score,
     createdAt: new Date(createdAt),
     updatedAt: new Date(updatedAt)
@@ -287,24 +294,28 @@ export type FeedInfo = {
   readonly title: string;
   readonly description: string;
   readonly entries: EntryInfo[];
+  readonly isLinked: boolean;
 };
 
 export function feedInfoFromJSON({
   url,
   title,
   description,
-  entries
+  entries,
+  isLinked
 }: {
   url: string;
   title: string;
   description: string;
   entries: any[];
+  isLinked: boolean;
 }): FeedInfo {
   return {
     url: toURL(url),
     title,
     description,
-    entries: entries.map(entryInfoFromJSON)
+    entries: entries.map(entryInfoFromJSON),
+    isLinked
   };
 }
 
@@ -478,3 +489,19 @@ export function collectionFeedInfoFromJSON({
     id: toFeedId(id)
   });
 }
+
+export class ApiMessage {
+  readonly type: string;
+  readonly code: string;
+  readonly message: string;
+
+  constructor({type, code, message}: {type: string; code: string; message: string}) {
+    this.type = type;
+    this.code = code;
+    this.message = message;
+  }
+}
+
+export function apiMessageFromJSON({type, code, message}: {type: string; code: string; message: string}): ApiMessage {
+  return new ApiMessage({type, code, message});
+}

package/src/stores/entries.ts

@@ -8,12 +8,14 @@ import * as api from "@/logic/api";
 import {Timer} from "@/logic/timer";
 import {computedAsync} from "@vueuse/core";
 import {useGlobalSettingsStore} from "@/stores/globalSettings";
+import * as events from "@/logic/events";
 
 export const useEntriesStore = defineStore("entriesStore", () => {
   const globalSettings = useGlobalSettingsStore();
 
   const entries = ref<{[key: t.EntryId]: t.Entry}>({});
   const requestedEntries = ref<{[key: t.EntryId]: boolean}>({});
+  const displayedEntryId = ref<t.EntryId | null>(null);
 
   function registerEntry(entry: t.Entry) {
     if (entry.id in entries.value) {
@@ -95,11 +97,35 @@ export const useEntriesStore = defineStore("entriesStore", () => {
     }
   }
 
+  async function displayEntry({entryId}: {entryId: t.EntryId}) {
+    displayedEntryId.value = entryId;
+
+    requestFullEntry({entryId: entryId});
+
+    if (!entries.value[entryId].hasMarker(e.Marker.Read)) {
+      await setMarker({
+        entryId: entryId,
+        marker: e.Marker.Read
+      });
+    }
+
+    await events.newsBodyOpened({entryId: entryId});
+  }
+
+  function hideEntry({entryId}: {entryId: t.EntryId}) {
+    if (displayedEntryId.value === entryId) {
+      displayedEntryId.value = null;
+    }
+  }
+
   return {
     entries,
     requestFullEntry,
     setMarker,
     removeMarker,
-    loadedEntriesReport
+    loadedEntriesReport,
+    displayedEntryId,
+    displayEntry,
+    hideEntry
   };
 });

package/src/stores/globalSettings.ts

@@ -18,7 +18,6 @@ export const useGlobalSettingsStore = defineStore("globalSettings", () => {
   // Entries
   const lastEntriesPeriod = ref(e.LastEntriesPeriod.Day3);
   const entriesOrder = ref(e.EntriesOrder.Score);
-  const showEntriesTags = ref(true);
   const showRead = ref(true);
 
   // Feeds
@@ -64,7 +63,6 @@ export const useGlobalSettingsStore = defineStore("globalSettings", () => {
     mainPanelMode,
     lastEntriesPeriod,
     entriesOrder,
-    showEntriesTags,
     showRead,
     dataVersion,
     updateDataVersion,

package/src/values/Score.vue

@@ -30,7 +30,7 @@
     for (const rule of rules) {
       const tags = [];
 
-      for (const tagId of rule.tags) {
+      for (const tagId of rule.requiredTags) {
         const tagInfo = tagsStore.tags[tagId];
         if (tagInfo) {
           tags.push(tagInfo.name);
@@ -39,7 +39,16 @@
         }
       }
 
-      strings.push(rule.score.toString().padStart(2, " ") + " — " + tags.join(", "));
+      for (const tagId of rule.excludedTags) {
+        const tagInfo = tagsStore.tags[tagId];
+        if (tagInfo) {
+          tags.push("NOT " + tagInfo.name);
+        } else {
+          tags.push("NOT " + tagId);
+        }
+      }
+
+      strings.push(rule.score.toString().padStart(2, " ") + " — " + tags.join(" AND "));
     }
 
     alert(strings.join("\n"));

package/src/views/DiscoveryView.vue

@@ -10,16 +10,26 @@
 
     <h2>Lood feeds from an OPML file</h2>
 
+    <div class="ffun-info-good">
+      <p>
+        <a
+          href="https://en.wikipedia.org/wiki/OPML"
+          target="_blank"
+          >OPML</a
+        >
+        is a widely-used format for transferring news feed lists between platforms.
+      </p>
+
+      <p
+        >Export your feeds from your old reader in OPML format and import them into our reader to seamlessly
+        transition!</p
+      >
+    </div>
+
     <opml-upload />
 
     <h2>Search for a feed</h2>
 
-    <div class="ffun-info-attention">
-      <p> The discovery feature is experimental and might not work on all websites. </p>
-
-      <p> If we can’t find a feed for a site, try finding the feed's URL manually, then enter it in the form. </p>
-    </div>
-
     <discovery-form />
   </side-panel-layout>
 </template>

package/src/views/FeedsView.vue

@@ -25,6 +25,15 @@
         off-text="last" />
     </template>
 
+    <template #side-menu-item-4>
+      <a
+        class="ffun-form-button p-1 my-1 block w-full text-center"
+        href="/api/get-opml"
+        target="_blank"
+        >Download OPML</a
+      >
+    </template>
+
     <template #main-header>
       Feeds
       <span v-if="sortedFeeds"> [{{ sortedFeeds.length }}] </span>

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>