applesauce-core 0.0.0-next-20250414124006 → 0.0.0-next-20250423151245

package/dist/helpers/blossom.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/blossom.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { areBlossomServersEqual } from "./blossom.js";
+describe("areBlossomServersEqual", () => {
+    it("should ignore path", () => {
+        expect(areBlossomServersEqual("https://cdn.server.com/pathname", "https://cdn.server.com")).toBe(true);
+    });
+    it("should not ignore protocol", () => {
+        expect(areBlossomServersEqual("http://cdn.server.com", "https://cdn.server.com")).toBe(false);
+    });
+    it("should not ignore port", () => {
+        expect(areBlossomServersEqual("http://cdn.server.com:4658", "https://cdn.server.com")).toBe(false);
+    });
+});

package/dist/helpers/bookmark.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export declare const BookmarkPublicSymbol: unique symbol;
+export declare const BookmarkHiddenSymbol: unique symbol;
+export type Bookmarks = {
+    notes: EventPointer[];
+    articles: AddressPointer[];
+    hashtags: string[];
+    urls: string[];
+};
+export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
+/** Returns the public bookmarks of the event */
+export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
+/** Returns the bookmarks of the event if its unlocked */
+export declare function getHiddenBookmarks(bookmark: NostrEvent): Bookmarks | undefined;

package/dist/helpers/bookmark.js

@@ -0,0 +1,27 @@
+import { kinds } from "nostr-tools";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getHiddenTags } from "./index.js";
+export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
+export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
+export function parseBookmarkTags(tags) {
+    const notes = tags.filter((t) => t[0] === "e" && t[1]).map(getEventPointerFromETag);
+    const articles = tags
+        .filter((t) => t[0] === "a" && t[1])
+        .map(getAddressPointerFromATag)
+        .filter((addr) => addr.kind === kinds.LongFormArticle);
+    const hashtags = tags.filter((t) => t[0] === "t" && t[1]).map((t) => t[1]);
+    const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
+    return { notes, articles, hashtags, urls };
+}
+/** Returns the public bookmarks of the event */
+export function getBookmarks(bookmark) {
+    return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
+}
+/** Returns the bookmarks of the event if its unlocked */
+export function getHiddenBookmarks(bookmark) {
+    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return tags && parseBookmarkTags(tags);
+    });
+}

package/dist/helpers/event.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/event.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { EventIndexableTagsSymbol, getIndexableTags, getTagValue } from "./event.js";
+const event = {
+    content: "",
+    created_at: 1732889913,
+    id: "2d53511f321cc82dd13eedfb597c9fe834d12d271c10d8068e9d8cfb8f58d1b4",
+    kind: 30000,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    sig: "e6a442487ef44a8a00ec1e0a852e547991fcd5cbf19aa1a4219fa65d6f41022675e0745207649f4b16fe9a6c5c7c3693dc3e13966ffa5b2891634867c874cf22",
+    tags: [
+        ["d", "qRxLhBbTfRlxsvKSu0iUl"],
+        ["title", "Musicians"],
+        ["client", "noStrudel", "31990:266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5:1686066542546"],
+        ["p", "2842e34860c59dfacd5df48ba7a65065e6760d08c35f779553d83c2c2310b493"],
+        ["p", "28ca019b78b494c25a9da2d645975a8501c7e99b11302e5cbe748ee593fcb2cc"],
+        ["p", "f46192b8b9be1b43fc30ea27c7cb16210aede17252b3aa9692fbb3f2ba153199"],
+    ],
+};
+describe("getIndexableTags", () => {
+    it("should return a set of indexable tags for event", () => {
+        expect(Array.from(getIndexableTags(event))).toEqual(expect.arrayContaining([
+            "p:2842e34860c59dfacd5df48ba7a65065e6760d08c35f779553d83c2c2310b493",
+            "p:28ca019b78b494c25a9da2d645975a8501c7e99b11302e5cbe748ee593fcb2cc",
+            "p:f46192b8b9be1b43fc30ea27c7cb16210aede17252b3aa9692fbb3f2ba153199",
+        ]));
+    });
+    it("should cache value on EventIndexableTagsSymbol", () => {
+        getIndexableTags(event);
+        expect(Reflect.has(event, EventIndexableTagsSymbol)).toBe(true);
+    });
+});
+describe("getTagValue", () => {
+    it("should return value of tag if present", () => {
+        expect(getTagValue(event, "title")).toBe("Musicians");
+    });
+});

package/dist/helpers/media-attachment.d.ts

@@ -0,0 +1,42 @@
+import { NostrEvent } from "nostr-tools";
+export type MediaAttachment = {
+    /** URL of the file */
+    url: string;
+    /** MIME type */
+    type?: string;
+    /** sha256 hash of the file */
+    sha256?: string;
+    /**
+     * The original sha256 hash before the file was transformed
+     * @deprecated
+     */
+    originalSha256?: string;
+    /** size of the file in bytes */
+    size?: number;
+    /** size of file in pixels in the form <width>x<height> */
+    dimensions?: string;
+    /** magnet */
+    magnet?: string;
+    /** torrent infohash */
+    infohash?: string;
+    /** URL to a thumbnail */
+    thumbnail?: string;
+    /** URL to a preview image with the same dimensions */
+    image?: string;
+    /** summary */
+    summary?: string;
+    /** description for accessability */
+    alt?: string;
+    /** blurhash */
+    blurhash?: string;
+    /** fallback URLs */
+    fallback?: string[];
+};
+/**
+ * Parses a imeta tag into a {@link MediaAttachment}
+ * @throws
+ */
+export declare function parseMediaAttachmentTag(tag: string[]): MediaAttachment;
+export declare const MediaAttachmentsSymbol: unique symbol;
+/** Gets all the media attachments on an event */
+export declare function getMediaAttachments(event: NostrEvent): MediaAttachment[];

package/dist/helpers/media-attachment.js

@@ -0,0 +1,72 @@
+import { getOrComputeCachedValue } from "./cache.js";
+/**
+ * Parses a imeta tag into a {@link MediaAttachment}
+ * @throws
+ */
+export function parseMediaAttachmentTag(tag) {
+    const parts = tag.slice(1);
+    const fields = {};
+    let fallback = undefined;
+    for (const part of parts) {
+        const match = part.match(/^(.+?)\s(.+)$/);
+        if (match) {
+            const [_, name, value] = match;
+            switch (name) {
+                case "fallback":
+                    fallback = fallback ? [...fallback, value] : [value];
+                    break;
+                default:
+                    fields[name] = value;
+                    break;
+            }
+        }
+    }
+    if (!fields.url)
+        throw new Error("Missing required url in attachment");
+    const attachment = { url: fields.url, fallback };
+    // parse size
+    if (fields.size)
+        attachment.size = parseInt(fields.size);
+    // copy optional fields
+    if (fields.m)
+        attachment.type = fields.m;
+    if (fields.x)
+        attachment.sha256 = fields.x;
+    if (fields.ox)
+        attachment.originalSha256 = fields.ox;
+    if (fields.dim)
+        attachment.dimensions = fields.dim;
+    if (fields.magnet)
+        attachment.magnet = fields.magnet;
+    if (fields.i)
+        attachment.infohash = fields.i;
+    if (fields.thumb)
+        attachment.thumbnail = fields.thumb;
+    if (fields.image)
+        attachment.image = fields.image;
+    if (fields.summary)
+        attachment.summary = fields.summary;
+    if (fields.alt)
+        attachment.alt = fields.alt;
+    if (fields.blurhash)
+        attachment.blurhash = fields.blurhash;
+    return attachment;
+}
+export const MediaAttachmentsSymbol = Symbol.for("media-attachments");
+/** Gets all the media attachments on an event */
+export function getMediaAttachments(event) {
+    return getOrComputeCachedValue(event, MediaAttachmentsSymbol, () => {
+        return event.tags
+            .filter((t) => t[0] === "imeta")
+            .map((tag) => {
+            try {
+                return parseMediaAttachmentTag(tag);
+            }
+            catch (error) {
+                // ignore invalid attachments
+                return undefined;
+            }
+        })
+            .filter((a) => !!a);
+    });
+}

package/dist/helpers/media-attachment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/media-attachment.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { parseMediaAttachmentTag } from "./media-attachment.js";
+describe("media attachment helpers", () => {
+    describe("parseMediaAttachmentTag", () => {
+        it("should parse simple imeta tag", () => {
+            expect(parseMediaAttachmentTag([
+                "imeta",
+                "url https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                "x 3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                "dim 1024x1024",
+                "m image/jpeg",
+                "blurhash ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+            ])).toEqual({
+                url: "https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                sha256: "3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                dimensions: "1024x1024",
+                type: "image/jpeg",
+                blurhash: "ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+            });
+        });
+        it("should parse thumbnail url", () => {
+            expect(parseMediaAttachmentTag([
+                "imeta",
+                "url https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                "x 3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                "dim 1024x1024",
+                "m image/jpeg",
+                "blurhash ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                "thumb https://exmaple.com/thumb.jpg",
+            ])).toEqual({
+                url: "https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                sha256: "3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                dimensions: "1024x1024",
+                type: "image/jpeg",
+                blurhash: "ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                thumbnail: "https://exmaple.com/thumb.jpg",
+            });
+        });
+        it("should parse multiple fallback urls", () => {
+            expect(parseMediaAttachmentTag([
+                "imeta",
+                "url https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                "x 3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                "dim 1024x1024",
+                "m image/jpeg",
+                "blurhash ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                "fallback https://exmaple.com/image2.jpg",
+                "fallback https://exmaple.com/image3.jpg",
+            ])).toEqual({
+                url: "https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                sha256: "3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                dimensions: "1024x1024",
+                type: "image/jpeg",
+                blurhash: "ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                fallback: ["https://exmaple.com/image2.jpg", "https://exmaple.com/image3.jpg"],
+            });
+        });
+    });
+});

package/dist/helpers/media-post.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MEDIA_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export declare function getMediaPostAttachments(post: NostrEvent): import("./file-metadata.js").FileMetadata[];

package/dist/helpers/media-post.js

@@ -0,0 +1,6 @@
+import { getMediaAttachments } from "./file-metadata.js";
+export const MEDIA_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export function getMediaPostAttachments(post) {
+    return getMediaAttachments(post);
+}

package/dist/helpers/mute.d.ts

@@ -0,0 +1,14 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MutePublicSymbol: unique symbol;
+export declare const MuteHiddenSymbol: unique symbol;
+export type Mutes = {
+    pubkeys: Set<string>;
+    threads: Set<string>;
+    hashtags: Set<string>;
+    words: Set<string>;
+};
+export declare function parseMutedTags(tags: string[][]): Mutes;
+/** Returns muted things */
+export declare function getMutedThings(mute: NostrEvent): Mutes;
+/** Returns the hidden muted content if the event is unlocked */
+export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;

package/dist/helpers/mute.js

@@ -0,0 +1,23 @@
+import { isETag, isPTag, isTTag } from "./tags.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getHiddenTags } from "./hidden-tags.js";
+export const MutePublicSymbol = Symbol.for("mute-public");
+export const MuteHiddenSymbol = Symbol.for("mute-hidden");
+export function parseMutedTags(tags) {
+    const pubkeys = new Set(tags.filter(isPTag).map((t) => t[1]));
+    const threads = new Set(tags.filter(isETag).map((t) => t[1]));
+    const hashtags = new Set(tags.filter(isTTag).map((t) => t[1].toLocaleLowerCase()));
+    const words = new Set(tags.filter((t) => t[0] === "word" && t[1]).map((t) => t[1].toLocaleLowerCase()));
+    return { pubkeys, threads, hashtags, words };
+}
+/** Returns muted things */
+export function getMutedThings(mute) {
+    return getOrComputeCachedValue(mute, MutePublicSymbol, (e) => parseMutedTags(e.tags));
+}
+/** Returns the hidden muted content if the event is unlocked */
+export function getHiddenMutedThings(mute) {
+    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => {
+        const tags = getHiddenTags(mute);
+        return tags && parseMutedTags(tags);
+    });
+}

package/dist/helpers/pipe.d.ts

@@ -0,0 +1,10 @@
+export type Pipe = {
+    <A>(a: A): A;
+    <A, B>(a: A, ab: (a: A) => B): B;
+    <A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+    <A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+    <A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+    <A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+    <A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
+};
+export declare const pipe: Pipe;

package/dist/helpers/pipe.js

@@ -0,0 +1,3 @@
+export const pipe = (initial, ...fns) => {
+    return fns.reduce((acc, fn) => fn(acc), initial);
+};

package/dist/helpers/tags.test.js

@@ -1,16 +1,24 @@
 import { describe, expect, it } from "vitest";
-import { isATag, processTags } from "./tags.js";
+import { isATag, isNameValueTag, processTags } from "./tags.js";
 import { getAddressPointerFromATag } from "./pointers.js";
-describe("tag helpers", () => {
-    describe("processTags", () => {
-        it("should filter out errors", () => {
-            expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], getAddressPointerFromATag)).toEqual([{ identifier: "list", kind: 30000, pubkey: "pubkey" }]);
-        });
-        it("should filter out undefined", () => {
-            expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], (tag) => isATag(tag) ? tag : undefined)).toEqual([
-                ["a", "bad coordinate"],
-                ["a", "30000:pubkey:list"],
-            ]);
-        });
+describe("isNameValueTag", () => {
+    it("should return true if tag has at least two indexes", () => {
+        expect(isNameValueTag(["a", "30000:pubkey:list"])).toBe(true);
+        expect(isNameValueTag(["title", "article", "other-value"])).toBe(true);
+    });
+    it("should ignore tags without values", () => {
+        expect(isNameValueTag(["a"])).toBe(false);
+        expect(isNameValueTag(["title"])).toBe(false);
+    });
+});
+describe("processTags", () => {
+    it("should filter out errors", () => {
+        expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], getAddressPointerFromATag)).toEqual([{ identifier: "list", kind: 30000, pubkey: "pubkey" }]);
+    });
+    it("should filter out undefined", () => {
+        expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], (tag) => isATag(tag) ? tag : undefined)).toEqual([
+            ["a", "bad coordinate"],
+            ["a", "30000:pubkey:list"],
+        ]);
     });
 });

package/dist/observable/{getValue.d.ts → get-value.d.ts}

@@ -1,2 +1,3 @@
 import { Observable } from "rxjs";
+/** Subscribes and returns the observables current or next value */
 export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/{getValue.js → get-value.js}

@@ -1,4 +1,5 @@
 import { BehaviorSubject } from "rxjs";
+/** Subscribes and returns the observables current or next value */
 export function getValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;

package/dist/observable/simple-timeout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/observable/simple-timeout.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { Observable, Subject, firstValueFrom } from "rxjs";
+import { simpleTimeout, TimeoutError } from "./simple-timeout.js";
+describe("simpleTimeout operator", () => {
+    it("should throw TimeoutError after specified timeout period", async () => {
+        const subject = new Subject();
+        const obs = subject.pipe(simpleTimeout(10));
+        const promise = firstValueFrom(obs);
+        await expect(promise).rejects.toThrow(TimeoutError);
+        await expect(promise).rejects.toThrow("Timeout");
+    });
+    it("should throw TimeoutError with custom message", async () => {
+        const subject = new Subject();
+        const customMessage = "Custom timeout message";
+        const obs = subject.pipe(simpleTimeout(10, customMessage));
+        const promise = firstValueFrom(obs);
+        await expect(promise).rejects.toThrow(TimeoutError);
+        await expect(promise).rejects.toThrow(customMessage);
+    });
+    it("should not throw when value emitted before timeout", async () => {
+        const subject = new Subject();
+        const obs = subject.pipe(simpleTimeout(1000));
+        const promise = firstValueFrom(obs);
+        subject.next("test value");
+        await expect(promise).resolves.toBe("test value");
+    });
+    it("should complete without error when source emits non-null value before timeout", async () => {
+        const source = new Observable((subscriber) => {
+            subscriber.next("test value");
+        });
+        const result = await firstValueFrom(source.pipe(simpleTimeout(10)));
+        expect(result).toBe("test value");
+    });
+});

package/dist/queries/comment.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** Returns all NIP-22 comment replies for the event */
+export declare function CommentsQuery(parent: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/comment.js

@@ -0,0 +1,14 @@
+import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+/** Returns all NIP-22 comment replies for the event */
+export function CommentsQuery(parent) {
+    return {
+        key: `${getEventUID(parent)}-comments`,
+        run: (events) => {
+            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+            if (isParameterizedReplaceableKind(parent.kind))
+                filter["#a"] = [getEventUID(parent)];
+            return events.timeline(filter);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250414124006",
+  "version": "0.0.0-next-20250423151245",
   "description": "",
   "type": "module",
   "main": "dist/index.js",

package/dist/observable/share-behavior.d.ts

@@ -1,2 +0,0 @@
-import { BehaviorSubject, Observable, UnaryFunction } from "rxjs";
-export declare function shareBehavior<T>(): UnaryFunction<Observable<T>, BehaviorSubject<T | undefined>>;

package/dist/observable/share-behavior.js

@@ -1,7 +0,0 @@
-import { BehaviorSubject, share } from "rxjs";
-export function shareBehavior() {
-    return share({
-        connector: () => new BehaviorSubject(undefined),
-        resetOnRefCountZero: false,
-    });
-}

package/dist/observable/stateful.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from "rxjs";
-export type StatefulObservable<T> = Observable<T> & {
-    _stateful?: true;
-    value?: T;
-    error?: Error;
-    complete?: boolean;
-};
-/** Wraps an {@link Observable} and makes it stateful */
-export declare function stateful<T extends unknown>(observable: Observable<T>, cleanup?: boolean): StatefulObservable<T>;
-export declare function isStateful<T extends unknown>(observable: Observable<T> | StatefulObservable<T>): observable is StatefulObservable<T>;

package/dist/observable/stateful.js

@@ -1,60 +0,0 @@
-import { Observable } from "rxjs";
-/** Wraps an {@link Observable} and makes it stateful */
-export function stateful(observable, cleanup = false) {
-    let subscription = undefined;
-    let observers = [];
-    const self = new Observable((observer) => {
-        // add observer to list
-        observers.push(observer);
-        // pass any cached values
-        if (self.value)
-            observer.next(self.value);
-        if (self.error)
-            observer.error(self.error);
-        if (self.complete)
-            observer.complete();
-        // subscribe if not already
-        if (!subscription) {
-            subscription = observable.subscribe({
-                next: (v) => {
-                    self.value = v;
-                    for (const observer of observers)
-                        observer.next(v);
-                },
-                error: (err) => {
-                    self.error = err;
-                    for (const observer of observers)
-                        observer.error(err);
-                },
-                complete: () => {
-                    self.complete = true;
-                    for (const observer of observers)
-                        observer.complete();
-                },
-            });
-        }
-        return () => {
-            let i = observers.indexOf(observer);
-            if (i !== -1) {
-                // remove observer from list
-                observers.splice(i, 1);
-                if (subscription && observers.length === 0) {
-                    subscription.unsubscribe();
-                    subscription = undefined;
-                    // reset cached values
-                    if (cleanup) {
-                        delete self.value;
-                        delete self.error;
-                        delete self.complete;
-                    }
-                }
-            }
-        };
-    });
-    self._stateful = true;
-    return self;
-}
-export function isStateful(observable) {
-    // @ts-expect-error
-    return observable._stateful;
-}

package/dist/observable/throttle.d.ts

@@ -1,3 +0,0 @@
-import Observable from "zen-observable";
-/** Throttles an {@link Observable} */
-export declare function throttle<T>(source: Observable<T>, interval: number): Observable<T>;

package/dist/observable/throttle.js

@@ -1,23 +0,0 @@
-import Observable from "zen-observable";
-/** Throttles an {@link Observable} */
-export function throttle(source, interval) {
-    return new Observable((observer) => {
-        let lastEmissionTime = 0;
-        let subscription = source.subscribe({
-            next(value) {
-                const currentTime = Date.now();
-                if (currentTime - lastEmissionTime >= interval) {
-                    lastEmissionTime = currentTime;
-                    observer.next(value);
-                }
-            },
-            error(err) {
-                observer.error(err);
-            },
-            complete() {
-                observer.complete();
-            },
-        });
-        return () => subscription.unsubscribe();
-    });
-}

package/dist/utils/lru.d.ts

@@ -1,32 +0,0 @@
-type Item<T> = {
-    key: string;
-    prev: Item<T> | null;
-    value: T;
-    next: Item<T> | null;
-    expiry: number;
-};
-/**
- * Copied from tiny-lru and modified to support typescript
- * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
- */
-export declare class LRU<T extends unknown> {
-    first: Item<T> | null;
-    items: Record<string, Item<T>>;
-    last: Item<T> | null;
-    max: number;
-    resetTtl: boolean;
-    size: number;
-    ttl: number;
-    constructor(max?: number, ttl?: number, resetTtl?: boolean);
-    clear(): this;
-    delete(key: string): this;
-    entries(keys?: string[]): (string | T | undefined)[][];
-    evict(bypass?: boolean): this;
-    expiresAt(key: string): number | undefined;
-    get(key: string): T | undefined;
-    has(key: string): boolean;
-    keys(): string[];
-    set(key: string, value: T, bypass?: boolean, resetTtl?: boolean): this;
-    values(keys?: string[]): NonNullable<T>[];
-}
-export {};

package/dist/utils/lru.js

@@ -1,148 +0,0 @@
-/**
- * Copied from tiny-lru and modified to support typescript
- * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
- */
-export class LRU {
-    first = null;
-    items = Object.create(null);
-    last = null;
-    max;
-    resetTtl;
-    size;
-    ttl;
-    constructor(max = 0, ttl = 0, resetTtl = false) {
-        this.first = null;
-        this.items = Object.create(null);
-        this.last = null;
-        this.max = max;
-        this.resetTtl = resetTtl;
-        this.size = 0;
-        this.ttl = ttl;
-    }
-    clear() {
-        this.first = null;
-        this.items = Object.create(null);
-        this.last = null;
-        this.size = 0;
-        return this;
-    }
-    delete(key) {
-        if (this.has(key)) {
-            const item = this.items[key];
-            delete this.items[key];
-            this.size--;
-            if (item.prev !== null) {
-                item.prev.next = item.next;
-            }
-            if (item.next !== null) {
-                item.next.prev = item.prev;
-            }
-            if (this.first === item) {
-                this.first = item.next;
-            }
-            if (this.last === item) {
-                this.last = item.prev;
-            }
-        }
-        return this;
-    }
-    entries(keys = this.keys()) {
-        return keys.map((key) => [key, this.get(key)]);
-    }
-    evict(bypass = false) {
-        if (bypass || this.size > 0) {
-            const item = this.first;
-            delete this.items[item.key];
-            if (--this.size === 0) {
-                this.first = null;
-                this.last = null;
-            }
-            else {
-                this.first = item.next;
-                this.first.prev = null;
-            }
-        }
-        return this;
-    }
-    expiresAt(key) {
-        let result;
-        if (this.has(key)) {
-            result = this.items[key].expiry;
-        }
-        return result;
-    }
-    get(key) {
-        let result;
-        if (this.has(key)) {
-            const item = this.items[key];
-            if (this.ttl > 0 && item.expiry <= Date.now()) {
-                this.delete(key);
-            }
-            else {
-                result = item.value;
-                this.set(key, result, true);
-            }
-        }
-        return result;
-    }
-    has(key) {
-        return key in this.items;
-    }
-    keys() {
-        const result = [];
-        let x = this.first;
-        while (x !== null) {
-            result.push(x.key);
-            x = x.next;
-        }
-        return result;
-    }
-    set(key, value, bypass = false, resetTtl = this.resetTtl) {
-        let item;
-        if (bypass || this.has(key)) {
-            item = this.items[key];
-            item.value = value;
-            if (bypass === false && resetTtl) {
-                item.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
-            }
-            if (this.last !== item) {
-                const last = this.last, next = item.next, prev = item.prev;
-                if (this.first === item) {
-                    this.first = item.next;
-                }
-                item.next = null;
-                item.prev = this.last;
-                last.next = item;
-                if (prev !== null) {
-                    prev.next = next;
-                }
-                if (next !== null) {
-                    next.prev = prev;
-                }
-            }
-        }
-        else {
-            if (this.max > 0 && this.size === this.max) {
-                this.evict(true);
-            }
-            item = this.items[key] = {
-                expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
-                key: key,
-                prev: this.last,
-                next: null,
-                value,
-            };
-            if (++this.size === 1) {
-                this.first = item;
-            }
-            else {
-                this.last.next = item;
-            }
-        }
-        this.last = item;
-        return this;
-    }
-    values(keys = this.keys()) {
-        return keys.map((key) => this.get(key));
-    }
-}