webring 1.5.1 → 1.6.0-dev.891

package/src/fetch.ts

@@ -1,19 +1,46 @@
 import Parser from "rss-parser";
 import sanitizeHtml from "sanitize-html";
 import * as truncateHtml from "truncate-html";
-import { type Source, type ResultEntry, FeedEntrySchema, type Configuration } from "./types.js";
+import { z } from "zod/v3";
+import {
+  type Source,
+  type ResultEntry,
+  FeedEntrySchema,
+  type Configuration,
+} from "./types.ts";
 import * as R from "remeda";
-import { asyncMapFilterUndefined } from "./util.js";
+import { asyncMapFilterUndefined } from "./util.ts";
 
 // Handle ESM/CommonJS interop - truncate-html exports differently in different environments
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-const truncate: (html: string, length?: number) => string = (truncateHtml as any).default ?? truncateHtml;
+const TruncateFnSchema = z
+  .function()
+  .args(z.string(), z.number().optional())
+  .returns(z.string());
+const TruncateModuleSchema = z.object({ default: TruncateFnSchema });
+
+function truncate(html: string, length?: number): string {
+  const mod = truncateHtml as unknown;
+  const fnResult = TruncateFnSchema.safeParse(mod);
+  if (fnResult.success) {
+    return fnResult.data(html, length);
+  }
+  const modResult = TruncateModuleSchema.safeParse(mod);
+  if (modResult.success) {
+    return modResult.data.default(html, length);
+  }
+  throw new Error("truncate-html module could not be resolved");
+}
 
 export async function fetchAll(config: Configuration) {
-  return await asyncMapFilterUndefined(config.sources, (source) => fetch(source, config.truncate));
+  return await asyncMapFilterUndefined(config.sources, (source) =>
+    fetch(source, config.truncate),
+  );
 }
 
-export async function fetch(source: Source, length: number): Promise<ResultEntry | undefined> {
+export async function fetch(
+  source: Source,
+  length: number,
+): Promise<ResultEntry | undefined> {
   const parser = new Parser();
 
   try {
@@ -32,17 +59,26 @@ export async function fetch(source: Source, length: number): Promise<ResultEntry
     }
 
     const preview =
-      firstItem.contentSnippet ?? firstItem.content ?? firstItem.description ?? firstItem["content:encoded"];
+      firstItem.contentSnippet ??
+      firstItem.content ??
+      firstItem.description ??
+      firstItem["content:encoded"];
 
     return {
       title: firstItem.title,
       url: firstItem.link,
       date: new Date(firstItem.date),
       source,
-      preview: preview ? truncate(sanitizeHtml(preview, { parseStyleAttributes: false }), length) : undefined,
+      preview:
+        preview !== undefined && preview !== ""
+          ? truncate(
+              sanitizeHtml(preview, { parseStyleAttributes: false }),
+              length,
+            )
+          : undefined,
     };
-  } catch (e) {
-    console.error(`Error fetching ${source.url}: ${e as string}`);
+  } catch (error) {
+    console.error(`Error fetching ${source.url}: ${String(error)}`);
     return undefined;
   }
 }

package/src/index.test.ts

@@ -1,33 +1,33 @@
-import { expect, test } from "vitest";
-import type { Configuration } from "./types.js";
-import { run } from "./index.js";
-import { tmpdir } from "os";
-import { mkdtemp } from "fs/promises";
-import { join } from "path";
+import { expect, test } from "bun:test";
+import type { Configuration } from "./types.ts";
+import { run } from "./index.ts";
+import { tmpdir } from "node:os";
+import { mkdtemp } from "node:fs/promises";
+import path from "node:path";
 import express from "express";
 
 const app = express();
 app.use(express.static("src/testdata"));
 
-const port = Math.floor(Math.random() * 10000) + 3000;
+const port = Math.floor(Math.random() * 10_000) + 3000;
 app.listen(port, () => {
-  console.log(`Test server listening at http://localhost:${port.toString()}`);
+  console.warn(`Test server listening at http://localhost:${port.toString()}`);
 });
 
 await new Promise((resolve) => setTimeout(resolve, 500));
 
-function createUrl(path: string): string {
-  return `http://localhost:${port.toString()}/${path}`;
+function createUrl(urlPath: string): string {
+  return `http://localhost:${port.toString()}/${urlPath}`;
 }
 
 function createSources(count: number): Configuration["sources"] {
   return Array.from({ length: count }, (_, i) => ({
-    title: `rss ${i.toString()}`,
-    url: createUrl(`rss-${i.toString()}.xml`),
+    title: `rss ${(i + 1).toString()}`,
+    url: createUrl(`rss-${(i + 1).toString()}.xml`),
   }));
 }
 
-test("it should fetch an RSS feed without caching", { timeout: 30000 }, async () => {
+test("it should fetch an RSS feed without caching", async () => {
   const config: Configuration = {
     sources: createSources(19),
     number: 1,
@@ -41,7 +41,7 @@ test("it should fetch an RSS feed without caching", { timeout: 30000 }, async ()
   expect(string).toMatchSnapshot();
 });
 
-test("it should fetch several RSS feeds", { timeout: 30000 }, async () => {
+test("it should fetch several RSS feeds", async () => {
   const config: Configuration = {
     sources: createSources(19),
     number: 3,
@@ -55,7 +55,7 @@ test("it should fetch several RSS feeds", { timeout: 30000 }, async () => {
   expect(string).toMatchSnapshot();
 });
 
-test("it should fetch an RSS feed with caching", { timeout: 30000 }, async () => {
+test("it should fetch an RSS feed with caching", async () => {
   const config: Configuration = {
     sources: createSources(19),
     number: 1,
@@ -76,6 +76,6 @@ test("it should fetch an RSS feed with caching", { timeout: 30000 }, async () =>
 // https://sdorra.dev/posts/2024-02-12-vitest-tmpdir
 async function createTempDir() {
   const ostmpdir = tmpdir();
-  const dir = join(ostmpdir, "unit-test-");
+  const dir = path.join(ostmpdir, "unit-test-");
   return await mkdtemp(dir);
 }

package/src/index.ts

@@ -1,35 +1,45 @@
 import * as R from "remeda";
-import { fetchAllCached as fetchAllCached } from "./cache.js";
-import { fetchAll as fetchAllUncached } from "./fetch.js";
-import { type Configuration, type Result, CachedConfigurationSchema } from "./types.js";
+import { fetchAllCached } from "./cache.ts";
+import { fetchAll as fetchAllUncached } from "./fetch.ts";
+import {
+  type Configuration,
+  type Result,
+  CachedConfigurationSchema,
+} from "./types.ts";
+
+export type { Configuration, Result, ResultEntry } from "./types.ts";
 
 export async function run(config: Configuration): Promise<Result> {
   const { success, data } = CachedConfigurationSchema.safeParse(config);
 
-  let result: Result;
+  let fetched: Result;
   if (success) {
-    console.log(`Using cache at ${data.cache.cache_file}.`);
-    result = await fetchAllCached(data);
+    console.warn(`Using cache at ${data.cache.cache_file}.`);
+    fetched = await fetchAllCached(data);
   } else {
-    console.log("Cache disabled.");
-    result = await fetchAllUncached(config);
+    console.warn("Cache disabled.");
+    fetched = await fetchAllUncached(config);
   }
 
   let results = R.pipe(
-    result,
-    R.sortBy((result) => result.date.getTime()),
+    fetched,
+    R.sortBy((entry) => entry.date.getTime()),
     R.reverse(),
-    R.filter((result) => {
-      if (result.source.filter && result.preview) {
-        return result.source.filter(result.preview);
-      } else {
+    R.filter((entry) => {
+      const filterFn = entry.source.filter;
+      if (
+        filterFn === undefined ||
+        entry.preview === undefined ||
+        entry.preview === ""
+      ) {
         return true;
       }
+      return filterFn(entry.preview);
     }),
   );
 
   // shuffle if wanted
-  if (config.shuffle) {
+  if (config.shuffle === true) {
     results = R.shuffle(results);
   }
 
@@ -38,5 +48,3 @@ export async function run(config: Configuration): Promise<Result> {
 
   return results;
 }
-
-export * from "./types.js";

package/src/types.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 
 export type Source = z.infer<typeof SourceSchema>;
 /** An RSS source */

package/src/util.ts

@@ -1,12 +1,18 @@
 import * as R from "remeda";
 
 // run an async map operation, filtering out undefined results
-export async function asyncMapFilterUndefined<T, U>(input: T[], fn: (x: T) => Promise<U | undefined>): Promise<U[]> {
+export async function asyncMapFilterUndefined<T, U>(
+  input: T[],
+  fn: (x: T) => Promise<U | undefined>,
+): Promise<U[]> {
   const results = await asyncMap(input, fn);
   return filterUndefined(results);
 }
 
-export async function asyncMap<T, U>(input: T[], fn: (x: T) => Promise<U>): Promise<U[]> {
+export async function asyncMap<T, U>(
+  input: T[],
+  fn: (x: T) => Promise<U>,
+): Promise<U[]> {
   const promises = R.pipe(
     input,
     R.map((item) => fn(item)),
@@ -16,8 +22,11 @@ export async function asyncMap<T, U>(input: T[], fn: (x: T) => Promise<U>): Prom
 }
 
 export function filterUndefined<T>(input: (T | undefined)[]): T[] {
-  return R.pipe(
-    input,
-    R.filter((result) => result !== undefined),
-  ) as T[];
+  const result: T[] = [];
+  for (const item of input) {
+    if (item !== undefined) {
+      result.push(item);
+    }
+  }
+  return result;
 }