@neurowire/core 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -296,6 +296,58 @@ type Mesh = z.infer<typeof MeshSchema>;
 /** Validate an unknown value into a Mesh. Throws (ZodError) on invalid input. */
 declare function parseMesh(data: unknown): Mesh;
 
+/**
+ * Pure dedup helpers for watch-style polling. They compute a stable identity per
+ * entry and select the entries a caller has not seen yet. No I/O, no clock, no
+ * network: the seen-state lives entirely in the calling app layer.
+ */
+/** Stable identity for dedup: the entry id when present, else its link. */
+declare function entryKey(entry: NeurowireEntry): string;
+/**
+ * The feed's entries whose {@link entryKey} is not in `seen`, in original order.
+ * `seen` is any iterable of keys (an array, a Set, ...); it is read once.
+ */
+declare function newEntries(feed: NeurowireFeed, seen: Iterable<string>): NeurowireEntry[];
+
+/**
+ * Pure, deterministic entry filtering by field and pattern. A rule matches a
+ * single field (title, summary, source, author, tag) against a substring or a
+ * regular expression. `filterEntries` keeps entries that satisfy an include set
+ * and avoid an exclude set. No I/O, no clock, no DOM.
+ */
+type FilterField = 'title' | 'summary' | 'source' | 'author' | 'tag';
+interface FilterRule {
+    field: FilterField;
+    pattern: string;
+    regex?: boolean;
+}
+interface FilterSpec {
+    include?: FilterRule[];
+    exclude?: FilterRule[];
+}
+/** Does any of the entry's values for the rule's field match the pattern? */
+declare function matchRule(entry: NeurowireEntry, rule: FilterRule): boolean;
+/**
+ * Keep an entry iff it matches at least one include rule (or there are none)
+ * and matches none of the exclude rules. An empty spec returns the feed
+ * entries unchanged.
+ */
+declare function filterEntries(feed: NeurowireFeed, spec: FilterSpec): NeurowireFeed;
+
+/**
+ * Stable, content-derived entry ids. Pure and dependency-free (no node:crypto)
+ * so core stays portable. Used to give entries that lack a real GUID a
+ * deterministic id, keeping dedup and round-trips stable across formats.
+ */
+/** FNV-1a (64-bit) hash of `input`, returned as a fixed 16-char lowercase hex string. */
+declare function hashHex(input: string): string;
+/**
+ * A deterministic synthetic id derived from an entry's link and title.
+ * Same `(link, title)` always yields the same urn; different inputs (essentially)
+ * always differ. Shape: `urn:nwf:<16-char hex>`.
+ */
+declare function stableId(link: string, title: string): string;
+
 /** One feed plus the source label its entries should carry in a merge. */
 interface MergePart {
     feed: NeurowireFeed;
@@ -434,4 +486,4 @@ declare function isFormat(value: string): value is Format;
 /** Serialize a feed to the requested format. */
 declare function serialize(feed: NeurowireFeed, format: Format): string;
 
-export { EXTENSIONS, EntrySchema, FORMATS, FeedSchema, type Format, GENERATOR, type JsonFeedDocument, MEDIA_TYPES, type MergeOptions, type MergePart, type Mesh, MeshSchema, type MeshSource, MeshSourceSchema, type NeurowireEntry, type NeurowireFeed, type NwfIssue, type NwfValidation, type Person, PersonSchema, type SelectOptions, type SortKey, type SortOrder, type TimeWindow, type WindowSpec, fromNwf, isFormat, mergeFeeds, parseDuration, parseMesh, parseNeurowireFeed, resolveWindow, selectEntries, serialize, toAtom, toJsonFeed, toJsonFeedObject, toMarkdown, toNwf, validateNwf };
+export { EXTENSIONS, EntrySchema, FORMATS, FeedSchema, type FilterField, type FilterRule, type FilterSpec, type Format, GENERATOR, type JsonFeedDocument, MEDIA_TYPES, type MergeOptions, type MergePart, type Mesh, MeshSchema, type MeshSource, MeshSourceSchema, type NeurowireEntry, type NeurowireFeed, type NwfIssue, type NwfValidation, type Person, PersonSchema, type SelectOptions, type SortKey, type SortOrder, type TimeWindow, type WindowSpec, entryKey, filterEntries, fromNwf, hashHex, isFormat, matchRule, mergeFeeds, newEntries, parseDuration, parseMesh, parseNeurowireFeed, resolveWindow, selectEntries, serialize, stableId, toAtom, toJsonFeed, toJsonFeedObject, toMarkdown, toNwf, validateNwf };

package/dist/index.js

@@ -1,3 +1,63 @@
+// src/diff.ts
+function entryKey(entry) {
+  return entry.id || entry.link;
+}
+function newEntries(feed, seen) {
+  const known = new Set(seen);
+  return feed.entries.filter((entry) => !known.has(entryKey(entry)));
+}
+
+// src/filter.ts
+function fieldValues(entry, field) {
+  switch (field) {
+    case "title":
+      return [entry.title];
+    case "summary":
+      return [entry.summary ?? ""];
+    case "source":
+      return [entry.source?.name ?? ""];
+    case "author":
+      return [(entry.authors ?? []).map((a) => a.name).join(" ")];
+    case "tag":
+      return entry.tags ?? [];
+  }
+}
+function matchRule(entry, rule) {
+  const values = fieldValues(entry, rule.field);
+  if (rule.regex) {
+    const re = new RegExp(rule.pattern, "i");
+    return values.some((value) => re.test(value));
+  }
+  const needle = rule.pattern.toLowerCase();
+  return values.some((value) => value.toLowerCase().includes(needle));
+}
+function filterEntries(feed, spec) {
+  const include = spec.include ?? [];
+  const exclude = spec.exclude ?? [];
+  if (include.length === 0 && exclude.length === 0) return feed;
+  const kept = feed.entries.filter((entry) => {
+    if (include.length > 0 && !include.some((rule) => matchRule(entry, rule))) return false;
+    if (exclude.some((rule) => matchRule(entry, rule))) return false;
+    return true;
+  });
+  return { ...feed, entries: kept };
+}
+
+// src/id.ts
+function hashHex(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= BigInt(input.charCodeAt(i));
+    hash = hash * prime & 0xffffffffffffffffn;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function stableId(link, title) {
+  return `urn:nwf:${hashHex(`${link}
+${title}`)}`;
+}
+
 // src/model.ts
 import { z } from "zod";
 var PersonSchema = z.object({
@@ -655,15 +715,21 @@ export {
   MeshSchema,
   MeshSourceSchema,
   PersonSchema,
+  entryKey,
+  filterEntries,
   fromNwf,
+  hashHex,
   isFormat,
+  matchRule,
   mergeFeeds,
+  newEntries,
   parseDuration,
   parseMesh,
   parseNeurowireFeed,
   resolveWindow,
   selectEntries,
   serialize,
+  stableId,
   toAtom,
   toJsonFeed,
   toJsonFeedObject,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neurowire/core",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Canonical feed model and serializers (Atom, JSON Feed 1.1, Markdown, nwf) for Neurowire.",
   "type": "module",
   "main": "./dist/index.js",