@manyducks.co/dolla 2.0.0-alpha.30 → 2.0.0-alpha.32

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,6 +1,6 @@
 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>];
 }
@@ -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.
      */
@@ -73,11 +73,19 @@ export interface StorableContext extends ComponentContext {
     /**
      * Attaches a new store to this context.
      */
-    attachStore(store: Store<any, any>): void;
+    attachStore(store: StoreFunction<{}, any>): void;
+    /**
+     * Attaches a new store to this context.
+     */
+    attachStore(store: StoreFunction<undefined, any>): void;
+    /**
+     * Attaches a new store to this context.
+     */
+    attachStore<Options>(store: StoreFunction<Options, any>, options: Options): void;
     /**
      * 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;
+    useStore<Value>(store: StoreFunction<any, Value>): Value;
 }
 /**
  * An event emitted from and received by a Dolla context. These are separate from DOM events.

package/dist/core/dolla.d.ts

@@ -1,6 +1,6 @@
 import { HTTP } from "../modules/http.js";
 import { I18n } from "../modules/i18n.js";
-import { Router } from "../modules/router.js";
+import { type Router } from "../modules/router.js";
 import { type CrashViewProps } from "../views/default-crash-view.js";
 import { Batch } from "./batch.js";
 import { ContextEvent, type StorableContext } from "./context.js";
@@ -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.
@@ -48,7 +48,6 @@ export declare class Dolla implements StorableContext {
     private readonly stats;
     readonly http: HTTP;
     readonly i18n: I18n;
-    readonly router: Router;
     constructor();
     watch: <I extends import("./state.js").MaybeState<any>[]>(states: [...I], fn: (...currentValues: import("./state.js").StateValues<I>) => void) => import("./state.js").StopFunction;
     createState: typeof createState;
@@ -81,7 +80,7 @@ export declare class Dolla implements StorableContext {
     /**
      * Returns the HTMLElement Dolla is mounted to. This will return undefined until Dolla.mount() is called.
      */
-    getRootElement(): HTMLElement | undefined;
+    getRootElement(): Element | undefined;
     /**
      * Returns the top level view Dolla is rendering inside the root element. This will return undefined until Dolla.mount() is called.
      */
@@ -116,13 +115,23 @@ export declare class Dolla implements StorableContext {
     /**
      * Attaches a new store to this context.
      */
-    attachStore(store: Store<any, any>): void;
+    attachStore(store: StoreFunction<{}, any>): void;
+    /**
+     * Attaches a new store to this context.
+     */
+    attachStore(store: StoreFunction<undefined, any>): void;
+    /**
+     * Attaches a new store to this context.
+     */
+    attachStore<Options>(store: StoreFunction<Options, any>, options: Options): void;
     /**
      * 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;
-    mount(selector: string, view?: ViewFunction<any>): Promise<void>;
-    mount(element: HTMLElement, view?: ViewFunction<any>): Promise<void>;
+    useStore<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>;
+    mount(element: Element, view: ViewFunction<any>): Promise<void>;
     unmount(): Promise<void>;
     /**
      * Registers a `callback` to run after `Dolla.mount` is called, before the app is mounted. If `callback` returns a Promise,

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/core/symbols.d.ts

@@ -4,3 +4,4 @@ export declare const IS_MARKUP: unique symbol;
 export declare const IS_MARKUP_ELEMENT: unique symbol;
 export declare const IS_STORE: unique symbol;
 export declare const IS_STORE_FACTORY: unique symbol;
+export declare const IS_ROUTER: unique symbol;

package/dist/index.d.ts

@@ -1,11 +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 StoreFunction, type StoreFactory } 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;