applesauce-core 0.0.0-next-20251203172109 → 0.0.0-next-20251205152544

package/dist/event-store/async-event-store.d.ts

@@ -28,19 +28,8 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     remove$: Subject<import("nostr-tools/core").Event>;
     /**
      * A method that will be called when an event isn't found in the store
-     * @experimental
      */
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /**
-     * A method that will be called when a replaceable event isn't found in the store
-     * @experimental
-     */
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /**
-     * A method that will be called when an addressable event isn't found in the store
-     * @experimental
-     */
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor(database: IAsyncEventDatabase);
     /** A method to add all events to memory to ensure there is only ever a single instance of an event */
     private mapToMemory;

package/dist/event-store/async-event-store.js

@@ -38,19 +38,8 @@ export class AsyncEventStore extends EventModels {
     remove$ = new Subject();
     /**
      * A method that will be called when an event isn't found in the store
-     * @experimental
      */
     eventLoader;
-    /**
-     * A method that will be called when a replaceable event isn't found in the store
-     * @experimental
-     */
-    replaceableLoader;
-    /**
-     * A method that will be called when an addressable event isn't found in the store
-     * @experimental
-     */
-    addressableLoader;
     constructor(database) {
         super();
         this.database = database;

package/dist/event-store/event-store.d.ts

@@ -26,21 +26,8 @@ export declare class EventStore extends EventModels implements IEventStore {
     update$: Subject<import("nostr-tools/core").Event>;
     /** A stream of events that have been removed */
     remove$: Subject<import("nostr-tools/core").Event>;
-    /**
-     * A method that will be called when an event isn't found in the store
-     * @experimental
-     */
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /**
-     * A method that will be called when a replaceable event isn't found in the store
-     * @experimental
-     */
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /**
-     * A method that will be called when an addressable event isn't found in the store
-     * @experimental
-     */
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** A method that will be called when an event isn't found in the store */
+    eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor(database?: IEventDatabase);
     /** A method to add all events to memory to ensure there is only ever a single instance of an event */
     private mapToMemory;

package/dist/event-store/event-store.js

@@ -38,21 +38,8 @@ export class EventStore extends EventModels {
     update$ = new Subject();
     /** A stream of events that have been removed */
     remove$ = new Subject();
-    /**
-     * A method that will be called when an event isn't found in the store
-     * @experimental
-     */
+    /** A method that will be called when an event isn't found in the store */
     eventLoader;
-    /**
-     * A method that will be called when a replaceable event isn't found in the store
-     * @experimental
-     */
-    replaceableLoader;
-    /**
-     * A method that will be called when an addressable event isn't found in the store
-     * @experimental
-     */
-    addressableLoader;
     constructor(database = new EventMemory()) {
         super();
         if (database) {

package/dist/event-store/interface.d.ts

@@ -99,7 +99,7 @@ export interface IEventModelMixin<TStore extends IEventStore | IAsyncEventStore>
     model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args, TStore>, ...args: Args): Observable<T>;
 }
 /** The interface that is passed to the model for creating subscriptions */
-export type ModelEventStore<TStore extends IEventStore | IAsyncEventStore> = IEventStoreStreams & IEventSubscriptions & IEventModelMixin<TStore> & IEventFallbackLoaders & TStore;
+export type ModelEventStore<TStore extends IEventStore | IAsyncEventStore> = IEventStoreStreams & IEventSubscriptions & IEventModelMixin<TStore> & IMissingEventLoader & TStore;
 /** A computed view of an event set or event store */
 export type Model<T extends unknown, TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> = (events: ModelEventStore<TStore>) => Observable<T>;
 /** A constructor for a {@link Model} */
@@ -136,17 +136,13 @@ export interface IEventMemory extends IEventStoreRead, IEventClaims {
     remove(event: string | NostrEvent): boolean;
 }
 /** A set of methods that an event store will use to load single events it does not have */
-export interface IEventFallbackLoaders {
+export interface IMissingEventLoader {
     /** A method that will be called when an event isn't found in the store */
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /** A method that will be called when a replaceable event isn't found in the store */
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /** A method that will be called when an addressable event isn't found in the store */
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
 }
 /** Generic async event store interface */
-export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventClaims, IEventFallbackLoaders, IEventStoreModels {
+export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventClaims, IMissingEventLoader, IEventStoreModels {
 }
 /** Generic sync event store interface */
-export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventClaims, IEventFallbackLoaders, IEventStoreModels {
+export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventClaims, IMissingEventLoader, IEventStoreModels {
 }

package/dist/models/base.js

@@ -38,24 +38,7 @@ function loadEventUsingFallback(store, pointer) {
         // If event was not found, attempt to load
         if (!store.eventLoader)
             return EMPTY;
-        return from(store.eventLoader(pointer));
-    });
-}
-/** If replaceable event is undefined, attempt to load using the fallback loader */
-function loadReplaceableUsingFallback(store, pointer) {
-    return switchMap((event) => {
-        if (event)
-            return of(event);
-        else if (pointer.identifier !== undefined) {
-            if (!store.addressableLoader)
-                return EMPTY;
-            return from(store.addressableLoader(pointer)).pipe(filter((e) => !!e));
-        }
-        else {
-            if (!store.replaceableLoader)
-                return EMPTY;
-            return from(store.replaceableLoader(pointer)).pipe(filter((e) => !!e));
-        }
+        return from(store.eventLoader(pointer)).pipe(filter((e) => !!e));
     });
 }
 /** A model that returns a single event or undefined when its removed */
@@ -88,7 +71,7 @@ export function ReplaceableModel(pointer) {
         // lazily get current event
         defer(() => getReplaceableFromStores(store, pointer)).pipe(
         // If the event isn't found, attempt to load using the fallback loader
-        loadReplaceableUsingFallback(store, pointer), 
+        loadEventUsingFallback(store, pointer), 
         // Only emit found events
         defined()), 
         // Subscribe to new events that match the pointer

package/package.json

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