@manyducks.co/dolla 0.69.3 → 0.69.5

package/lib/app.d.ts

@@ -53,9 +53,6 @@ interface ConfigureContext {
 type ConfigureCallback = (ctx: ConfigureContext) => void | Promise<void>;
 export interface IApp {
     readonly isConnected: boolean;
-    /**
-     * Makes this store accessible from any other component in the app, except for stores registered before this one.
-     */
     /**
      * Runs `callback` after app-level stores are connected to the app, but before views are connected to the DOM.
      * Use this function to run async configuration code before displaying content to the user.

package/lib/classes/EventEmitter.d.ts

@@ -0,0 +1,44 @@
+type EventListeners<E extends EventMap> = {
+    [K in keyof E]?: EventCallback<E, K>[];
+};
+export type EventCallback<E extends EventMap, K extends keyof E> = (event: EmittedEvent<E, K>) => void;
+/**
+ * A map of event names and data values that their listener callbacks take.
+ */
+export interface EventMap {
+    [name: string]: any;
+}
+/**
+ * A hub for subscribing to and emitting events. A good pattern when you want to notify several parts of your app
+ * at once when a condition changes in a central location. This is a similar pattern to Readable and Writable as far as
+ * observability goes, but with the added ability to emit multiple event types each with their own separate listeners.
+ */
+export declare class EventEmitter<E extends EventMap = EventMap> {
+    listeners: EventListeners<E>;
+    /**
+     * Emit an event.
+     */
+    emit<K extends keyof E>(name: K, data: E[K]): void;
+    /**
+     * Listen for an event. The callback will be called whenever that event is emitted.
+     * Returns a function that will cancel this listener when called.
+     */
+    on<K extends keyof EventListeners<E>>(name: K, callback: EventCallback<E, K>): () => void;
+    /**
+     * Listen for the next emitted event. The callback will be called once the next time that event is emitted,
+     * and then never again. Returns a function that will cancel this listener when called.
+     */
+    once<K extends keyof EventListeners<E>>(name: K, callback: EventCallback<E, K>): () => void;
+    /**
+     * Cancel a listener by passing the callback that was originally used to register it.
+     */
+    off<K extends keyof EventListeners<E>>(name: K, callback: EventCallback<E, K>): void;
+}
+declare class EmittedEvent<E extends EventMap, K extends keyof E> {
+    /**
+     * Data object emitted with this event.
+     */
+    data: E[K];
+    constructor(data: E[K]);
+}
+export {};