@manyducks.co/dolla 2.0.0-alpha.31 → 2.0.0-alpha.33

package/README.md

@@ -35,9 +35,9 @@ Dolla's goals include:
 A basic view. Note that the view function is called exactly once when the view is first mounted. All changes to DOM nodes thereafter happen as a result of `$state` values changing.
 
 ```js
-import Dolla, { createState, createView } from "@manyducks.co/dolla";
+import Dolla, { createState } from "@manyducks.co/dolla";
 
-const Counter = createView(function (props) {
+function Counter() {
   const [$count, setCount] = createState(0);
 
   function increment() {

package/dist/core/context.d.ts

@@ -1,8 +1,8 @@
 import type { Emitter } from "@manyducks.co/emitter";
-import type { Store, StoreFactory } from "./store";
 import type { Dolla } from "./dolla";
+import type { Store, StoreFunction } from "./store";
 interface ContextEmitterEvents {
-    [eventName: string | symbol]: [ContextEvent<any>];
+    [eventName: string | symbol]: [ContextEvent, ...args: any[]];
 }
 export interface ElementContext {
     /**
@@ -20,7 +20,7 @@ export interface ElementContext {
     /**
      * Stores attached to this context.
      */
-    stores: Map<string, Store<any, any>>;
+    stores: Map<StoreFunction<any, any>, Store<any, any>>;
     /**
      * A reference to the parent context.
      */
@@ -39,7 +39,7 @@ export interface ElementContext {
  * Wrapping listeners is necessary because the context API's `.on` method does not pass the event name to "*" listeners while the emitter does.
  * ContextEvent objects already have the event name stored as `event.type`.
  */
-export type WildcardListenerMap = Map<(event: ContextEvent<any>) => void, (eventName: string | symbol, event: ContextEvent<any>) => void>;
+export type WildcardListenerMap = Map<(event: ContextEvent, ...args: any[]) => void, (eventName: string | symbol, event: ContextEvent, ...args: any[]) => void>;
 export interface ComponentContext {
     /**
      * Sets a context variable and returns its value.
@@ -50,45 +50,52 @@ export interface ComponentContext {
      */
     get<T>(key: string | symbol): T | null;
     /**
-     * Adds a listener to be called when `eventName` is emitted.
+     * Adds a listener to be called when an event with a matching `type` is emitted.
      */
-    on<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    on<T = unknown>(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
     /**
-     * Removes a listener from the list to be called when `eventName` is emitted.
+     * Removes a listener from the list to be called when an event with a matching `type` is emitted.
      */
-    off<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    off<T = unknown>(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
     /**
-     * Adds a listener to be called when `eventName` is emitted. The listener is immediately removed after being called once.
+     * Adds a listener to be called when an event with a matching `type` is emitted. The listener is immediately removed after being called once.
      */
-    once<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    once<T = unknown>(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
     /**
      * Emits a new event to all listeners.
      */
-    emit<T = unknown>(eventName: string, detail: T): boolean;
+    emit<T = unknown>(type: string, ...args: any[]): boolean;
 }
 /**
  * A context capable of hosting stores.
  */
 export interface StorableContext extends ComponentContext {
     /**
-     * Attaches a new store to this context.
+     * Attaches a new store to this context and returns it.
      */
-    attachStore(store: Store<any, any>): void;
+    provide<Value>(store: StoreFunction<{}, Value>): Value;
+    /**
+     * Attaches a new store to this context and returns it.
+     */
+    provide<Value>(store: StoreFunction<undefined, Value>): Value;
+    /**
+     * Attaches a new store to this context and returns it.
+     */
+    provide<Options, Value>(store: StoreFunction<Options, Value>, options: Options): Value;
     /**
      * Gets the closest instance of a store. Throws an error if the store isn't provided higher in the tree.
      */
-    useStore<Value>(factory: StoreFactory<any, Value>): Value;
+    use<Value>(store: StoreFunction<any, Value>): Value;
 }
 /**
  * An event emitted from and received by a Dolla context. These are separate from DOM events.
  */
-export declare class ContextEvent<T> {
+export declare class ContextEvent {
     #private;
-    type: string;
-    detail: T;
-    get propagationStopped(): boolean;
-    constructor(type: string, detail: T);
-    stopPropagation(): void;
+    constructor(type: string);
+    get type(): string;
+    get isStopped(): boolean;
+    stop(): void;
     get [Symbol.toStringTag](): string;
 }
 export {};

package/dist/core/dolla.d.ts

@@ -8,7 +8,7 @@ import { type Markup, type MarkupElement } from "./markup.js";
 import { type ViewElement, type ViewFunction } from "./nodes/view.js";
 import { createRef, isRef } from "./ref.js";
 import { createState, createWatcher, derive, isState, toState, toValue } from "./state.js";
-import { type Store, type StoreFactory } from "./store.js";
+import { StoreFunction } from "./store.js";
 export type Environment = "development" | "production";
 /**
  * Log type toggles. Each message category can be turned on or off or enabled only in a specific environment.
@@ -97,29 +97,37 @@ export declare class Dolla implements StorableContext {
      * Returns an object of all context variables stored at the app level.
      */
     /**
-     * Adds a listener to be called when `eventName` is emitted.
+     * Adds a listener to be called when an event with a matching `type` is emitted.
      */
-    on<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    on<T = unknown>(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
     /**
-     * Removes a listener from the list to be called when `eventName` is emitted.
+     * Removes a listener from the list to be called when an event with a matching `type` is emitted.
      */
-    off<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    off<T = unknown>(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
     /**
-     * Adds a listener to be called when `eventName` is emitted. The listener is immediately removed after being called once.
+     * Adds a listener to be called when an event with a matching `type` is emitted. The listener is immediately removed after being called once.
      */
-    once<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    once<T = unknown>(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
     /**
      * Emits a new event to all listeners.
      */
-    emit<T = unknown>(eventName: string, detail: T): boolean;
+    emit<T = unknown>(type: string, ...args: any[]): boolean;
     /**
      * Attaches a new store to this context.
      */
-    attachStore(store: Store<any, any>): void;
+    provide<Value>(store: StoreFunction<{}, Value>): Value;
+    /**
+     * Attaches a new store to this context.
+     */
+    provide<Value>(store: StoreFunction<undefined, Value>): Value;
+    /**
+     * Attaches a new store to this context.
+     */
+    provide<Options, Value>(store: StoreFunction<Options, Value>, options: Options): Value;
     /**
      * Gets the nearest instance of a store. Throws an error if the store isn't provided higher in the tree.
      */
-    useStore<Value>(factory: StoreFactory<any, Value>): Value;
+    use<Value>(store: StoreFunction<any, Value>): Value;
     mount(selector: string, router: Router): Promise<void>;
     mount(selector: string, view: ViewFunction<any>): Promise<void>;
     mount(element: Element, router: Router): Promise<void>;

package/dist/core/markup.d.ts

@@ -2,6 +2,27 @@ import type { Renderable } from "../types.js";
 import type { ElementContext } from "./context.js";
 import { type ViewContext, type ViewFunction, type ViewResult } from "./nodes/view.js";
 import { type MaybeState, type State } from "./state.js";
+import { IS_MARKUP } from "./symbols.js";
+export declare class _Markup implements Markup {
+    [IS_MARKUP]: boolean;
+    static text(value: MaybeState<string>): _Markup;
+    static from(renderable: Renderable): Markup;
+    /**
+     * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
+     * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
+     */
+    type: string | ViewFunction<any>;
+    /**
+     * Data that will be passed to a new MarkupElement instance when it is constructed.
+     */
+    props: Record<string, any> | undefined;
+    /**
+     *
+     */
+    children: Markup[];
+    constructor(type: string | ViewFunction<any>, props?: Record<string, any>, children?: Renderable[]);
+    toElement(context: ElementContext): MarkupElement;
+}
 /**
  * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
  */
@@ -68,9 +89,9 @@ export declare function createMarkup<I>(type: ViewFunction<I>, attributes?: I, .
  */
 export declare const html: (strings: TemplateStringsArray, ...values: any[]) => Markup | Markup[];
 /**
- * Displays content conditionally. When `predicate` holds a truthy value, `thenContent` is displayed; when `predicate` holds a falsy value, `elseContent` is displayed.
+ * Displays content conditionally. When `condition` holds a truthy value, `thenContent` is displayed; when `condition` holds a falsy value, `elseContent` is displayed.
  */
-export declare function cond(predicate: MaybeState<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+export declare function cond(condition: MaybeState<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
 /**
  * Calls `renderFn` for each item in `items`. Dynamically adds and removes views as items change.
  * The result of `keyFn` is used to compare items and decide if item was added, removed or updated.

package/dist/core/nodes/view.d.ts

@@ -1,5 +1,5 @@
 import { Emitter } from "@manyducks.co/emitter";
-import { type WildcardListenerMap, type ElementContext, type StorableContext } from "../context.js";
+import { type ElementContext, type StorableContext, type WildcardListenerMap } from "../context.js";
 import type { Logger } from "../dolla.js";
 import { type Markup, type MarkupElement } from "../markup.js";
 import { type MaybeState, type State, type StateValues, type StopFunction } from "../state.js";
@@ -60,7 +60,6 @@ export interface ViewContext extends Logger, StorableContext {
      */
     outlet(): Markup;
 }
-export declare function createView<Props extends Record<string, any> = Record<string, unknown>>(fn: ViewFunction<Props>): ViewFunction<Props>;
 type ViewEvents = {
     beforeMount: [];
     mounted: [];

package/dist/core/store.d.ts

@@ -1,5 +1,5 @@
 import { Emitter } from "@manyducks.co/emitter";
-import { type WildcardListenerMap, type ComponentContext, type ElementContext } from "./context.js";
+import { type ComponentContext, type ElementContext, type WildcardListenerMap } from "./context.js";
 import type { Logger } from "./dolla.js";
 import { type MaybeState, type StateValues, type StopFunction } from "./state.js";
 export type StoreFunction<Options, Value> = (this: StoreContext, options: Options, context: StoreContext) => Value;
@@ -28,8 +28,7 @@ type StoreEvents = {
     unmounted: [];
 };
 export declare class Store<Options, Value> {
-    readonly key: string;
-    private _fn;
+    readonly fn: StoreFunction<Options, Value>;
     private _options;
     /**
      * Value is guaranteed to be set after `attach` is called.
@@ -42,7 +41,7 @@ export declare class Store<Options, Value> {
     _logger: Logger;
     _watcher: import("./state.js").StateWatcher;
     get name(): string;
-    constructor(key: string, fn: StoreFunction<Options, Value>, options: Options);
+    constructor(fn: StoreFunction<Options, Value>, options: Options);
     /**
      * Attaches this Store to the elementContext.
      * Returns false if there was already an instance attached, and true otherwise.
@@ -51,12 +50,7 @@ export declare class Store<Options, Value> {
     handleMount(): void;
     handleUnmount(): void;
 }
-export declare function isStoreFactory<Options, Value>(value: any): value is StoreFactory<Options, Value>;
 export declare function isStore<Options, Value>(value: any): value is Store<Options, Value>;
-/**
- * Defines a new store.
- */
-export declare function createStore<Options = undefined, Value = unknown>(fn: StoreFunction<Options, Value>): StoreFactory<Options, Value>;
 export declare class StoreError extends Error {
 }
 export {};

package/dist/index.d.ts

@@ -1,12 +1,11 @@
 export { createState, derive, isState, toState, toValue } from "./core/state.js";
 export type { MaybeState, Setter, State, StopFunction } from "./core/state.js";
 export { createRef, isRef, type Ref } from "./core/ref.js";
-export { createStore, type Store, type StoreFactory, type StoreFunction } from "./core/store.js";
+export { type StoreFunction, type StoreContext } from "./core/store.js";
 export { createRouter, type Router, type RouterOptions } from "./modules/router.js";
 export { deepEqual, shallowEqual, strictEqual } from "./utils.js";
 export { cond, createMarkup, html, portal, repeat } from "./core/markup.js";
 export type { Markup, MarkupElement } from "./core/markup.js";
-export { createView } from "./core/nodes/view.js";
 import { Dolla } from "./core/dolla.js";
 declare const dolla: Dolla;
 export default dolla;