feeds-fun 1.17.0 → 1.18.0

package/src/layouts/SidePanelLayout.vue

@@ -49,29 +49,41 @@
     <div class="ffun-body-panel">
       <div class="ffun-page-header">
         <div class="ffun-page-header-left-block">
-          <template
-            v-for="[mode, props] of e.MainPanelModeProperties"
-            :key="mode">
-            <a
-              v-if="globalSettings.mainPanelMode !== mode"
-              :href="router.resolve({name: mode, params: {}}).href"
-              class="ffun-page-header-link"
-              @click.prevent="router.push({name: mode, params: {}})">
-              {{ props.text }}
-            </a>
-
-            <span
-              class="ffun-page-header-link-disabled"
-              v-else
-              >{{ props.text }}</span
-            >
+          <a
+            v-if="homeButton"
+            :href="router.resolve({name: 'main', params: {}}).href"
+            class="ffun-page-header-link"
+            >Home</a
+          >
+
+          <template v-if="globalState.isLoggedIn">
+            <template
+              v-for="[mode, props] of e.MainPanelModeProperties"
+              :key="mode">
+              <template v-if="props.showInMenu">
+                <a
+                  v-if="globalSettings.mainPanelMode !== mode"
+                  :href="router.resolve({name: mode, params: {}}).href"
+                  class="ffun-page-header-link"
+                  @click.prevent="router.push({name: mode, params: {}})">
+                  {{ props.text }}
+                </a>
+
+                <span
+                  class="ffun-page-header-link-disabled"
+                  v-else
+                  >{{ props.text }}</span
+                >
+              </template>
+            </template>
           </template>
 
-          <page-header-external-links :show-api="true" />
+          <page-header-external-links :show-api="globalState.isLoggedIn" />
         </div>
 
         <div class="ffun-page-header-right-block">
           <a
+            v-if="globalState.isLoggedIn"
             href="#"
             class="ffun-page-header-link"
             @click.prevent="logout()"
@@ -110,10 +122,14 @@
   const router = useRouter();
   const slots = useSlots();
 
-  const properties = withDefaults(defineProps<{reloadButton?: boolean; loginRequired?: boolean}>(), {
-    reloadButton: true,
-    loginRequired: true
-  });
+  const properties = withDefaults(
+    defineProps<{reloadButton?: boolean; loginRequired?: boolean; homeButton?: boolean}>(),
+    {
+      reloadButton: true,
+      loginRequired: true,
+      homeButton: false
+    }
+  );
 
   async function logout() {
     if (settings.authMode === settings.AuthMode.SingleUser) {
@@ -122,7 +138,10 @@
     }
 
     await supertokens.logout();
-    router.push({name: "main", params: {}});
+
+    if (properties.loginRequired) {
+      router.push({name: "main", params: {}});
+    }
   }
 
   const hasSideFooter = computed(() => {

package/src/layouts/WideLayout.vue

@@ -1,9 +1,5 @@
 <template>
-  <!-- <div class="flex justify-center h-screen"> -->
-  <!-- <div class="flex flex-col justify-start items-center text-center p-4"> -->
   <slot></slot>
-  <!-- </div> -->
-  <!-- </div> -->
 </template>
 
 <script lang="ts" setup></script>

package/src/logic/api.ts

@@ -7,6 +7,7 @@ const ENTRY_POINT = "/api";
 
 const API_GET_FEEDS = `${ENTRY_POINT}/get-feeds`;
 const API_GET_LAST_ENTRIES = `${ENTRY_POINT}/get-last-entries`;
+const API_GET_LAST_COLLECTION_ENTRIES = `${ENTRY_POINT}/get-last-collection-entries`;
 const API_GET_ENTRIES_BY_IDS = `${ENTRY_POINT}/get-entries-by-ids`;
 const API_CREATE_OR_UPDATE_RULE = `${ENTRY_POINT}/create-or-update-rule`;
 
@@ -83,6 +84,28 @@ export async function getLastEntries({period}: {period: number}) {
   return entries;
 }
 
+export async function getLastCollectionEntries({
+  period,
+  collectionSlug
+}: {
+  period: number;
+  collectionSlug: t.CollectionSlug | null;
+}) {
+  const response = await post({
+    url: API_GET_LAST_COLLECTION_ENTRIES,
+    data: {period: period, collectionSlug: collectionSlug}
+  });
+
+  const entries = [];
+
+  for (let rawEntry of response.entries) {
+    const entry = t.entryFromJSON(rawEntry, response.tagsMapping);
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
 export async function getEntriesByIds({ids}: {ids: t.EntryId[]}) {
   const response = await post({
     url: API_GET_ENTRIES_BY_IDS,

package/src/logic/enums.ts

@@ -10,16 +10,23 @@ export enum MainPanelMode {
   Rules = "rules",
   Discovery = "discovery",
   Collections = "collections",
+  PublicCollection = "public-collection",
   Settings = "settings"
 }
 
-export const MainPanelModeProperties = new Map<MainPanelMode, {text: string}>([
-  [MainPanelMode.Entries, {text: "News"}],
-  [MainPanelMode.Feeds, {text: "Feeds"}],
-  [MainPanelMode.Rules, {text: "Rules"}],
-  [MainPanelMode.Discovery, {text: "Discovery"}],
-  [MainPanelMode.Collections, {text: "Collections"}],
-  [MainPanelMode.Settings, {text: "Settings"}]
+export type MainPanelModeProperty = {
+  readonly text: string;
+  readonly showInMenu: boolean;
+};
+
+export const MainPanelModeProperties = new Map<MainPanelMode, MainPanelModeProperty>([
+  [MainPanelMode.Entries, {text: "News", showInMenu: true}],
+  [MainPanelMode.Feeds, {text: "Feeds", showInMenu: true}],
+  [MainPanelMode.Rules, {text: "Rules", showInMenu: true}],
+  [MainPanelMode.Discovery, {text: "Discovery", showInMenu: true}],
+  [MainPanelMode.Collections, {text: "Collections", showInMenu: true}],
+  [MainPanelMode.PublicCollection, {text: "Public Collection", showInMenu: false}],
+  [MainPanelMode.Settings, {text: "Settings", showInMenu: true}]
 ]);
 
 export enum LastEntriesPeriod {
@@ -38,8 +45,13 @@ export enum LastEntriesPeriod {
   AllTime = "alltime"
 }
 
+export type LastEntriesPeriodProperty = {
+  readonly text: string;
+  readonly seconds: number;
+};
+
 // Map preserves the order of the keys
-export const LastEntriesPeriodProperties = new Map<LastEntriesPeriod, {text: string; seconds: number}>([
+export const LastEntriesPeriodProperties = new Map<LastEntriesPeriod, LastEntriesPeriodProperty>([
   [LastEntriesPeriod.Hour1, {text: "1 hour", seconds: c.hour}],
   [LastEntriesPeriod.Hour3, {text: "3 hours", seconds: 3 * c.hour}],
   [LastEntriesPeriod.Hour6, {text: "6 hours", seconds: 6 * c.hour}],
@@ -63,10 +75,14 @@ export enum EntriesOrder {
   Cataloged = "cataloged"
 }
 
-export const EntriesOrderProperties = new Map<
-  EntriesOrder,
-  {text: string; orderField: string; timeField: string; direction: number}
->([
+export type EntriesOrderProperty = {
+  readonly text: string;
+  readonly orderField: string;
+  readonly timeField: string;
+  readonly direction: number;
+};
+
+export const EntriesOrderProperties = new Map<EntriesOrder, EntriesOrderProperty>([
   [EntriesOrder.Score, {text: "score", orderField: "score", timeField: "catalogedAt", direction: 1}],
   [EntriesOrder.ScoreToZero, {text: "score ~ 0", orderField: "scoreToZero", timeField: "catalogedAt", direction: 1}],
   [EntriesOrder.ScoreBackward, {text: "score backward", orderField: "score", timeField: "catalogedAt", direction: -1}],

package/src/logic/events.ts

@@ -1,37 +1,65 @@
 import * as api from "@/logic/api";
 import type * as t from "@/logic/types";
+import {inject} from "vue";
 import type {State as TagState} from "@/logic/tagsFilterState";
 
-export type TagChangeSource = "news_tags_filter" | "rules_tags_filter" | "entry_record" | "rule_record";
+export type EventsViewName =
+  | "news"
+  | "rules"
+  | "public_collections"
+  | "auth"
+  | "settings"
+  | "discovery"
+  | "feeds"
+  | "main"
+  | "collections";
+export type TagChangeSource = "tags_filter" | "entry_record" | "rule_record";
 
-export async function newsLinkOpened({entryId}: {entryId: t.EntryId}) {
-  await api.trackEvent({name: "news_link_opened", entry_id: entryId});
+export async function newsLinkOpened({entryId, view}: {entryId: t.EntryId; view: EventsViewName}) {
+  await api.trackEvent({
+    name: "news_link_opened",
+    view: view,
+    entry_id: entryId
+  });
 }
 
-export async function newsBodyOpened({entryId}: {entryId: t.EntryId}) {
-  await api.trackEvent({name: "news_body_opened", entry_id: entryId});
+export async function newsBodyOpened({entryId, view}: {entryId: t.EntryId; view: EventsViewName}) {
+  await api.trackEvent({
+    name: "news_body_opened",
+    view: view,
+    entry_id: entryId
+  });
 }
 
-export async function socialLinkClicked({linkType}: {linkType: string}) {
-  await api.trackEvent({name: "social_link_clicked", link_type: linkType});
+export async function socialLinkClicked({linkType, view}: {linkType: string; view: EventsViewName}) {
+  await api.trackEvent({
+    name: "social_link_clicked",
+    view: view,
+    link_type: linkType
+  });
 }
 
 export async function tagStateChanged({
   tag,
   fromState,
   toState,
-  source
+  source,
+  view
 }: {
   tag: string;
   fromState: TagState;
   toState: TagState;
   source: TagChangeSource;
+  view: EventsViewName;
 }) {
+  // const eventsView = inject<events.EventViewName>("eventsViewName");
+
   await api.trackEvent({
     name: "tag_filter_state_changed",
     tag: tag,
     from_state: fromState,
     to_state: toState,
+    view: view,
     source: source
   });
 }

package/src/logic/tagsFilterState.ts

@@ -1,5 +1,6 @@
-import {ref, computed, reactive} from "vue";
+import {ref, computed, reactive, watch} from "vue";
 import type {ComputedRef} from "vue";
+import _ from "lodash";
 
 export type State = "required" | "excluded" | "none";
 
@@ -102,6 +103,34 @@ export class Storage {
     return report;
   }
 
+  tagsForUrl() {
+    const selectedTags = Object.keys(this.selectedTags).sort();
+
+    const tags = [];
+
+    for (const tag of selectedTags) {
+      if (this.requiredTags[tag]) {
+        tags.push(tag);
+      } else {
+        tags.push(`-${tag}`);
+      }
+    }
+
+    return tags;
+  }
+
+  setTagsFromUrl(tags: string[]) {
+    this.clear();
+
+    for (const tag of tags) {
+      if (tag.startsWith("-")) {
+        this.excludedTags[tag.slice(1)] = true;
+      } else {
+        this.requiredTags[tag] = true;
+      }
+    }
+  }
+
   clear() {
     Object.keys(this.requiredTags).forEach((key) => {
       delete this.requiredTags[key];
@@ -112,3 +141,23 @@ export class Storage {
     });
   }
 }
+
+// must be called synchoronously from the view
+export function setSyncingTagsWithRoute({tagsStates, route, router}: {tagsStates: Storage; route: any; router: any}) {
+  if (!route.params.tags) {
+    tagsStates.setTagsFromUrl([]);
+  } else {
+    tagsStates.setTagsFromUrl(route.params.tags);
+  }
+
+  watch(tagsStates, () => {
+    const newParams = _.clone(route.params);
+    newParams.tags = tagsStates.tagsForUrl();
+
+    router.push({
+      replace: true,
+      name: route.name,
+      params: newParams
+    });
+  });
+}

package/src/logic/types.ts

@@ -24,6 +24,12 @@ export function toCollectionId(id: string): CollectionId {
   return id as CollectionId;
 }
 
+export type CollectionSlug = string & {readonly __brand: unique symbol};
+
+export function toCollectionSlug(slug: string): CollectionSlug {
+  return slug as CollectionSlug;
+}
+
 export type URL = string & {readonly __brand: unique symbol};
 
 export function toURL(url: string): URL {
@@ -233,7 +239,7 @@ export type Rule = {
   readonly id: RuleId;
   readonly requiredTags: string[];
   readonly excludedTags: string[];
-  readonly allTags: string[];
+  readonly tags: string[];
   readonly score: number;
   readonly createdAt: Date;
   readonly updatedAt: Date;
@@ -261,7 +267,7 @@ export function ruleFromJSON({
     id: toRuleId(id),
     requiredTags: requiredTags,
     excludedTags: excludedTags,
-    allTags: requiredTags.concat(excludedTags).sort(),
+    tags: requiredTags.concat(excludedTags).sort(),
     score: score,
     createdAt: new Date(createdAt),
     updatedAt: new Date(updatedAt)
@@ -411,6 +417,7 @@ export function resourceHistoryRecordFromJSON({
 
 export class Collection {
   readonly id: CollectionId;
+  readonly slug: CollectionSlug;
   readonly guiOrder: number;
   readonly name: string;
   readonly description: string;
@@ -419,6 +426,7 @@ export class Collection {
 
   constructor({
     id,
+    slug,
     guiOrder,
     name,
     description,
@@ -426,6 +434,7 @@ export class Collection {
     showOnMain
   }: {
     id: CollectionId;
+    slug: CollectionSlug;
     guiOrder: number;
     name: string;
     description: string;
@@ -433,6 +442,7 @@ export class Collection {
     showOnMain: boolean;
   }) {
     this.id = id;
+    this.slug = slug;
     this.guiOrder = guiOrder;
     this.name = name;
     this.description = description;
@@ -443,6 +453,7 @@ export class Collection {
 
 export function collectionFromJSON({
   id,
+  slug,
   guiOrder,
   name,
   description,
@@ -450,6 +461,7 @@ export function collectionFromJSON({
   showOnMain
 }: {
   id: string;
+  slug: string;
   guiOrder: number;
   name: string;
   description: string;
@@ -458,6 +470,7 @@ export function collectionFromJSON({
 }): Collection {
   return {
     id: toCollectionId(id),
+    slug: toCollectionSlug(slug),
     guiOrder: guiOrder,
     name: name,
     description: description,

package/src/logic/utils.ts

@@ -1,4 +1,5 @@
 import _ from "lodash";
+import type * as t from "@/logic/types";
 import DOMPurify from "dompurify";
 
 export function timeSince(date: Date) {
@@ -64,7 +65,6 @@ export function faviconForUrl(url: string): string | null {
     const parsedUrl = new URL(url);
     return `${parsedUrl.protocol}//${parsedUrl.host}/favicon.ico`;
   } catch (error) {
-    console.error("Invalid URL:", error);
     return null;
   }
 }
@@ -96,3 +96,106 @@ export function purifyBody({raw, default_}: {raw: string | null; default_: strin
 
   return body;
 }
+
+export function chooseTagByUsage({
+  tagsCount,
+  border,
+  exclude
+}: {
+  tagsCount: {[key: string]: number};
+  border: number;
+  exclude: string[];
+}) {
+  if (Object.keys(tagsCount).length === 0) {
+    return null;
+  }
+
+  if (!exclude) {
+    exclude = [];
+  }
+
+  const tags = _.toPairs(tagsCount).sort((a, b) => {
+    if (a[1] === b[1]) {
+      return a[0].localeCompare(b[0]);
+    }
+
+    return b[1] - a[1];
+  });
+
+  for (let i = 0; i < tags.length; i++) {
+    if (exclude.includes(tags[i][0])) {
+      continue;
+    }
+
+    if (tags[i][1] < border) {
+      return tags[i][0];
+    }
+  }
+
+  return tags[tags.length - 1][0];
+}
+
+export function countTags(entries: t.Entry[] | t.Rule[] | null) {
+  if (!entries) {
+    return {};
+  }
+
+  const tagsCount: {[key: string]: number} = {};
+
+  for (const entry of entries) {
+    for (const tag of entry.tags) {
+      if (tag in tagsCount) {
+        tagsCount[tag] += 1;
+      } else {
+        tagsCount[tag] = 1;
+      }
+    }
+  }
+
+  return tagsCount;
+}
+
+export function sortIdsList<ID extends string = string>({
+  ids,
+  storage,
+  field,
+  direction
+}: {
+  ids: ID[];
+  storage: {[key: string]: any};
+  field: string;
+  direction: number;
+}) {
+  // Pre-map to avoid repeated lookups in the comparator
+  // required for the cases when storage is reactive
+  const mapped = ids.map((id) => {
+    // @ts-ignore
+    return {id, value: storage[id][field]};
+  });
+
+  mapped.sort((a: {id: ID; value: any}, b: {id: ID; value: any}) => {
+    if (a.value === null && b.value === null) {
+      return 0;
+    }
+
+    if (a.value === null) {
+      return 1;
+    }
+
+    if (b.value === null) {
+      return -1;
+    }
+
+    if (a.value < b.value) {
+      return direction;
+    }
+
+    if (a.value > b.value) {
+      return -direction;
+    }
+
+    return 0;
+  });
+
+  return mapped.map((x) => x.id);
+}

package/src/main.ts

@@ -38,6 +38,7 @@ import PageHeaderExternalLinks from "./components/page_header/ExternalLinks.vue"
 import NotificationsApiKey from "./components/notifications/ApiKey.vue";
 import NotificationsCreateRuleHelp from "./components/notifications/CreateRuleHelp.vue";
 import Notifications from "./components/notifications/Block.vue";
+import NotificationsLoadedOldNews from "./components/notifications/LoadedOldNews.vue";
 
 import CollectionsNotification from "./components/collections/Notification.vue";
 import CollectionsWarning from "./components/collections/Warning.vue";
@@ -46,6 +47,8 @@ import CollectionsBlockItem from "./components/collections/BlockItem.vue";
 import CollectionsDetailedItem from "./components/collections/DetailedItem.vue";
 import CollectionsSubscribingProgress from "./components/collections/SubscribingProgress.vue";
 import CollectionsFeedItem from "./components/collections/FeedItem.vue";
+import CollectionsPublicSelector from "./components/collections/PublicSelector.vue";
+import CollectionsPublicIntro from "./components/collections/PublicIntro.vue";
 
 import ScoreSelector from "./inputs/ScoreSelector.vue";
 
@@ -105,6 +108,7 @@ app.component("PageHeaderExternalLinks", PageHeaderExternalLinks);
 app.component("NotificationsApiKey", NotificationsApiKey);
 app.component("NotificationsCreateRuleHelp", NotificationsCreateRuleHelp);
 app.component("Notifications", Notifications);
+app.component("NotificationsLoadedOldNews", NotificationsLoadedOldNews);
 
 app.component("CollectionsNotification", CollectionsNotification);
 app.component("CollectionsWarning", CollectionsWarning);
@@ -113,6 +117,8 @@ app.component("CollectionsBlockItem", CollectionsBlockItem);
 app.component("CollectionsDetailedItem", CollectionsDetailedItem);
 app.component("CollectionsSubscribingProgress", CollectionsSubscribingProgress);
 app.component("CollectionsFeedItem", CollectionsFeedItem);
+app.component("CollectionsPublicSelector", CollectionsPublicSelector);
+app.component("CollectionsPublicIntro", CollectionsPublicIntro);
 
 app.component("ScoreSelector", ScoreSelector);
 

package/src/router/index.ts

@@ -7,6 +7,7 @@ import RulesView from "../views/RulesView.vue";
 import DiscoveryView from "../views/DiscoveryView.vue";
 import CollectionsView from "../views/CollectionsView.vue";
 import SettingsView from "../views/SettingsView.vue";
+import PublicCollectionView from "../views/PublicCollectionView.vue";
 import * as e from "@/logic/enums";
 
 // lazy view loading does not work with router.push function
@@ -31,12 +32,12 @@ const router = createRouter({
       component: FeedsView
     },
     {
-      path: "/news",
+      path: "/news/:tags*",
       name: e.MainPanelMode.Entries,
       component: NewsView
     },
     {
-      path: "/rules",
+      path: "/rules/:tags*",
       name: e.MainPanelMode.Rules,
       component: RulesView
     },
@@ -54,8 +55,20 @@ const router = createRouter({
       path: "/settings",
       name: e.MainPanelMode.Settings,
       component: SettingsView
+    },
+    {
+      path: "/show/:collectionSlug/:tags*",
+      name: "public-collection",
+      component: PublicCollectionView
+    },
+    {
+      path: "/:pathMatch(.*)*",
+      redirect: "/"
     }
-  ]
+  ],
+  scrollBehavior(to, from, savedPosition) {
+    return {top: 0};
+  }
 });
 
 export default router;

package/src/stores/collections.ts

@@ -33,6 +33,10 @@ export const useCollectionsStore = defineStore("collectionsStore", () => {
     return order;
   });
 
+  const collectionsOrdered = computed(() => {
+    return collectionsOrder.value.map((id) => collections.value[id]);
+  });
+
   async function getFeeds({collectionId}: {collectionId: t.CollectionId}) {
     if (collectionId in feeds.value) {
       return feeds.value[collectionId];
@@ -45,9 +49,21 @@ export const useCollectionsStore = defineStore("collectionsStore", () => {
     return feeds.value[collectionId];
   }
 
+  function getCollectionBySlug({slug}: {slug: t.CollectionSlug}) {
+    for (const collection of Object.values(collections.value)) {
+      if (collection.slug === slug) {
+        return collection;
+      }
+    }
+
+    return null;
+  }
+
   return {
     collections,
     collectionsOrder,
-    getFeeds
+    collectionsOrdered,
+    getFeeds,
+    getCollectionBySlug
   };
 });