@manyducks.co/dolla 2.0.0-alpha.35 → 2.0.0-alpha.37

package/README.md

@@ -25,7 +25,7 @@ Dolla's goals include:
 
 > TODO: Write about why Dolla was started and what it's all about.
 
-- Borne of frustration using React and similar libs (useEffect, referential equality, a pain to integrate other libs into its lifecycle, need to hunt for libraries to move beyond Hello World).
+- Borne of frustration using React and similar libs (useEffect, referential equality, a pain to integrate other libs into its lifecycle, need to hunt for libraries to move much beyond Hello World).
 - Merges ideas from my favorite libraries and frameworks (Solid/Knockout, Choo, Svelte, i18next, etc) into one curated set designed to work well together.
 - Opinionated (with the _correct_ opinions).
 - Many mainstream libraries seem too big for what they do. The entirety of Dolla is less than half the size of [`react-router`](https://bundlephobia.com/package/react-router@7.1.5).
@@ -49,17 +49,6 @@ function Counter() {
       </div>
     </div>
   `;
-
-  return (
-    <div>
-      <p>Clicks: {$count}</p>
-      <div>
-        <button onClick={decrement}>-1</button>
-        <button onClick={reset}>Reset</button>
-        <button onClick={increment}>+1</button>
-      </div>
-    </div>
-  );
 });
 
 Dolla.mount(document.body, Counter);

package/dist/core/context.d.ts

@@ -1,28 +1,10 @@
-import type { Emitter } from "@manyducks.co/emitter";
 import type { Dolla } from "./dolla";
 import type { Store, StoreFunction } from "./store";
-export interface GenericEvents {
-    [type: string]: [...args: any[]];
-}
-export interface GenericContextData {
-    [key: string | symbol]: any;
-}
-export interface ContextEmitterEvents {
-    [type: string | symbol]: [ContextEvent, ...args: any[]];
-}
 export interface ElementContext {
     /**
      * The root Dolla instance this element belongs to.
      */
     root: Dolla;
-    /**
-     * Storage for context variables.
-     */
-    data: Record<string | symbol, unknown>;
-    /**
-     * Event emitter for this context.
-     */
-    emitter: Emitter<ContextEmitterEvents>;
     /**
      * Stores attached to this context.
      */
@@ -40,33 +22,11 @@ export interface ElementContext {
      */
     viewName?: string;
 }
-/**
- * Mapping of listener function passed to `.on` -> wrapped versions that discard eventName.
- * 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, ...args: any[]) => void, (eventName: string | symbol, event: ContextEvent, ...args: any[]) => void>;
-export interface ComponentContext<Events extends GenericEvents = GenericEvents> {
+export interface ComponentContext {
     /**
      * A name for debugging purposes. Prepended to log messages.
      */
     name: string;
-    /**
-     * Adds a listener to be called when an event with a matching `type` is emitted.
-     */
-    on<T extends keyof Events>(type: T, listener: (event: ContextEvent, ...args: Events[T]) => void): void;
-    /**
-     * Removes a listener from the list to be called when an event with a matching `type` is emitted.
-     */
-    off(type: string, listener: (event: ContextEvent, ...args: any[]) => void): void;
-    /**
-     * 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 extends keyof Events>(type: T, listener: (event: ContextEvent, ...args: Events[T]) => void): void;
-    /**
-     * Emits a new event to all listeners.
-     */
-    emit<T extends keyof Events>(type: T, ...args: Events[T]): boolean;
 }
 /**
  * A context capable of providing stores.
@@ -91,14 +51,3 @@ export interface StoreConsumerContext {
      */
     get<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 {
-    #private;
-    constructor(type: string);
-    get type(): string;
-    get isStopped(): boolean;
-    stop(): void;
-    get [Symbol.toStringTag](): string;
-}

package/dist/core/dolla.d.ts

@@ -1,11 +1,11 @@
 import { HTTP } from "../http/index.js";
-import { I18n } from "../translate/index.js";
 import { type Router } from "../router/index.js";
-import { type CrashViewProps } from "./views/default-crash-view.js";
-import { type StoreProviderContext, type StoreConsumerContext } from "./context.js";
+import { I18n } from "../translate/index.js";
+import type { StoreConsumerContext, StoreProviderContext } from "./context.js";
 import { type Markup, type MarkupElement } from "./markup.js";
 import { type ViewElement, type ViewFunction } from "./nodes/view.js";
 import { StoreFunction } from "./store.js";
+import { type CrashViewProps } from "./views/default-crash-view.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.
@@ -125,4 +125,4 @@ export declare class Dolla implements StoreProviderContext, StoreConsumerContext
      */
     constructMarkup(markup: Markup | Markup[]): MarkupElement;
 }
-export declare function getDefaultConsole(): any;
+export declare function getDefaultConsole(): Console | undefined;

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

@@ -1,7 +1,7 @@
 import type { Renderable } from "../../types.js";
 import type { ElementContext } from "../context.js";
 import { type MarkupElement } from "../markup.js";
-import { type Reactive, type UnsubscribeFunction } from "../signals.js";
+import { type Reactive } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 interface DynamicOptions {
     source: Reactive<Renderable>;
@@ -14,10 +14,10 @@ interface DynamicOptions {
 export declare class Dynamic implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     node: Text;
-    children: MarkupElement[];
-    elementContext: ElementContext;
-    source: Reactive<Renderable>;
-    unsubscribe?: UnsubscribeFunction;
+    private children;
+    private elementContext;
+    private source;
+    private unsubscribe?;
     get isMounted(): boolean;
     constructor(options: DynamicOptions);
     mount(parent: Node, after?: Node): void;

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

@@ -1,7 +1,5 @@
 import { type ElementContext } from "../context.js";
 import { type Markup, type MarkupElement } from "../markup.js";
-import { type Ref } from "../ref.js";
-import { type MaybeReactive, type UnsubscribeFunction } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 type HTMLOptions = {
     elementContext: ElementContext;
@@ -12,23 +10,21 @@ type HTMLOptions = {
 export declare class HTML implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     node: HTMLElement | SVGElement;
-    props: Record<string, any>;
-    childMarkup: Markup[];
-    children: MarkupElement[];
-    unsubscribers: UnsubscribeFunction[];
-    elementContext: ElementContext;
-    uniqueId: string;
-    ref?: Ref<any>;
-    canClickAway: boolean;
+    private props;
+    private childMarkup;
+    private children;
+    private unsubscribers;
+    private elementContext;
+    private ref?;
+    private canClickAway;
     get isMounted(): boolean;
     constructor({ tag, props, children, elementContext }: HTMLOptions);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
-    getUpdateKey(type: string, value: string | number): string;
-    attachProp<T>(value: MaybeReactive<T>, callback: (value: T) => void): void;
-    applyProps(element: HTMLElement | SVGElement, props: Record<string, unknown>): void;
-    applyStyles(element: HTMLElement | SVGElement, styles: unknown, unsubscribers: UnsubscribeFunction[]): () => void;
-    applyClasses(element: HTMLElement | SVGElement, classes: unknown, unsubscribers: UnsubscribeFunction[]): () => void;
+    private attachProp;
+    private applyProps;
+    private applyStyles;
+    private applyClasses;
 }
 /**
  * Converts a camelCase string to kebab-case.

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

@@ -1,6 +1,6 @@
 import { type ElementContext } from "../context.js";
 import { type MarkupElement } from "../markup.js";
-import { type Atom, type Reactive, type UnsubscribeFunction } from "../signals.js";
+import { type Reactive } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 import { type ViewContext, type ViewResult } from "./view.js";
 interface ListOptions<T> {
@@ -9,26 +9,20 @@ interface ListOptions<T> {
     keyFn: (item: T, index: number) => string | number | symbol;
     renderFn: (item: Reactive<T>, index: Reactive<number>, ctx: ViewContext) => ViewResult;
 }
-type ConnectedItem<T> = {
-    key: any;
-    item: Atom<T>;
-    index: Atom<number>;
-    element: MarkupElement;
-};
 export declare class List<T> implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     node: Text;
-    items: Reactive<T[]>;
-    unsubscribe: UnsubscribeFunction | null;
-    connectedItems: ConnectedItem<T>[];
-    elementContext: ElementContext;
-    renderFn: (this: ViewContext, value: Reactive<T>, index: Reactive<number>, context: ViewContext) => ViewResult;
-    keyFn: (value: T, index: number) => string | number | symbol;
+    private items;
+    private unsubscribe;
+    private connectedItems;
+    private elementContext;
+    private renderFn;
+    private keyFn;
     get isMounted(): boolean;
     constructor({ elementContext, items, renderFn, keyFn }: ListOptions<T>);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
-    _cleanup(parentIsUnmounting: boolean): void;
-    _update(value: T[]): void;
+    private _cleanup;
+    private _update;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { type MarkupElement } from "../markup.js";
-import { type MaybeReactive, type UnsubscribeFunction } from "../signals.js";
+import { type MaybeReactive } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 /**
  * Manages several MarkupElements as one.
@@ -8,12 +8,12 @@ export declare class Outlet implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     node: Text;
     isMounted: boolean;
-    source: MaybeReactive<MarkupElement[]>;
-    elements: MarkupElement[];
-    unsubscribe?: UnsubscribeFunction;
+    private source;
+    private elements;
+    private unsubscribe?;
     constructor(source: MaybeReactive<MarkupElement[]>);
     mount(parent: Node, after?: Node | undefined): void;
     unmount(parentIsUnmounting?: boolean): void;
-    cleanup(parentIsUnmounting: boolean): void;
-    update(newElements: MarkupElement[]): void;
+    private cleanup;
+    private update;
 }

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

@@ -12,8 +12,8 @@ interface PortalConfig {
  */
 export declare class Portal implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
-    config: PortalConfig;
-    element?: MarkupElement;
+    private config;
+    private element?;
     get isMounted(): boolean;
     constructor(config: PortalConfig);
     mount(_parent: Node, _after?: Node): void;

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

@@ -1,7 +1,6 @@
-import { Emitter } from "@manyducks.co/emitter";
-import { type ComponentContext, type ElementContext, type GenericEvents, type StoreConsumerContext, type StoreProviderContext, type WildcardListenerMap } from "../context.js";
+import type { ComponentContext, ElementContext, StoreConsumerContext, StoreProviderContext } from "../context.js";
 import type { Logger } from "../dolla.js";
-import { cond, list, portal, type Markup, type MarkupElement } from "../markup.js";
+import { type Markup, type MarkupElement } from "../markup.js";
 import { type EffectCallback, type Reactive, type UnsubscribeFunction } from "../signals.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 /**
@@ -18,7 +17,7 @@ export interface ViewElement extends MarkupElement {
      */
     setChildView(view: ViewFunction<{}>): ViewElement;
 }
-export interface ViewContext<Events extends GenericEvents = GenericEvents> extends Omit<Logger, "setName">, ComponentContext<Events>, StoreProviderContext, StoreConsumerContext {
+export interface ViewContext extends Omit<Logger, "setName">, ComponentContext, StoreProviderContext, StoreConsumerContext {
     /**
      * An ID unique to this view.
      */
@@ -48,43 +47,28 @@ export interface ViewContext<Events extends GenericEvents = GenericEvents> exten
      * Callback will be run each time a tracked state gets a new value.
      */
     effect(callback: EffectCallback): UnsubscribeFunction;
-    /**
-     * Renders a list of reactive items.
-     */
-    list: typeof list;
-    /**
-     * Creates a reactive conditional; the second argument is displayed when the condition is true and the third is displayed when the condition is false.
-     */
-    if: typeof cond;
     /**
      * Returns a Markup element that displays this view's children.
      */
     outlet(): Markup;
-    /**
-     * Displays an element as a child of another DOM node, rather than the position it would normally be mounted at.
-     */
-    portal: typeof portal;
 }
-type ViewEvents = {
-    beforeMount: [];
-    mounted: [];
-    beforeUnmount: [];
-    unmounted: [];
-};
 export declare class View<P> implements ViewElement {
     [IS_MARKUP_ELEMENT]: boolean;
     uniqueId: string;
-    _elementContext: ElementContext;
-    _logger: Logger;
-    _view: ViewFunction<P>;
-    _props: P;
-    _element?: MarkupElement;
-    _childMarkup: Markup[];
-    _children: import("../signals.js").Atom<MarkupElement[]>;
-    _unsubscribes: UnsubscribeFunction[];
-    _emitter: Emitter<ViewEvents>;
-    _wildcardListeners: WildcardListenerMap;
-    constructor(elementContext: ElementContext, view: ViewFunction<P>, props: P, children?: Markup[]);
+    elementContext: ElementContext;
+    logger: Logger;
+    props: P;
+    fn: ViewFunction<P>;
+    element?: MarkupElement;
+    childMarkup: Markup[];
+    children: import("../signals.js").Atom<MarkupElement[]>;
+    lifecycleListeners: {
+        beforeMount: (() => any)[];
+        mount: (() => any)[];
+        beforeUnmount: (() => any)[];
+        unmount: (() => any)[];
+    };
+    constructor(elementContext: ElementContext, fn: ViewFunction<P>, props: P, children?: Markup[]);
     get node(): Node;
     isMounted: boolean;
     mount(parent: Node, after?: Node): void;
@@ -92,4 +76,3 @@ export declare class View<P> implements ViewElement {
     setChildView(fn: ViewFunction<{}>): View<{}>;
     private _initialize;
 }
-export {};

package/dist/core/ref.d.ts

@@ -12,22 +12,6 @@ export interface Ref<T> {
      */
     <T>(value: T | undefined): void;
 }
-/**
- * A Ref is a function that returns the last argument it was called with.
- * Calling it with no arguments will simply return the latest value.
- * Calling it with an argument will store that value and immediately return it.
- *
- * @param value - An (optional) initial value to store.
- *
- * @deprecated
- *
- * @example
- * const ref = createRef(5);
- * ref(); // 5
- * ref(500);
- * ref(); // 500
- */
-export declare function createRef<T>(value?: T): Ref<T>;
 /**
  * A Ref is a function that returns the last argument it was called with.
  * Calling it with no arguments will simply return the latest value.
@@ -42,4 +26,3 @@ export declare function createRef<T>(value?: T): Ref<T>;
  * number(); // 500
  */
 export declare function ref<T>(value?: T): Ref<T>;
-export declare function isRef<T extends Node>(value: any): value is Ref<T>;

package/dist/core/signals.d.ts

@@ -36,9 +36,6 @@ export interface ReactiveOptions<T> {
 }
 export declare class Atom<T> implements Reactive<T> {
     #private;
-    /**
-     * A label for debugging purposes.
-     */
     name?: string;
     constructor(signal: Signal<T>, options?: ReactiveOptions<T>);
     get value(): T;

package/dist/core/store.d.ts

@@ -1,10 +1,9 @@
-import { Emitter } from "@manyducks.co/emitter";
-import { GenericEvents, StoreConsumerContext, type ComponentContext, type ElementContext, type WildcardListenerMap } from "./context.js";
+import type { StoreConsumerContext, ComponentContext, ElementContext } from "./context.js";
 import type { Logger } from "./dolla.js";
 import { EffectCallback, UnsubscribeFunction } from "./signals.js";
 export type StoreFunction<Options, Value> = (this: StoreContext, options: Options, context: StoreContext) => Value;
 export type StoreFactory<Options, Value> = Options extends undefined ? () => Store<Options, Value> : (options: Options) => Store<Options, Value>;
-export interface StoreContext<Events extends GenericEvents = GenericEvents> extends Omit<Logger, "setName">, ComponentContext<Events>, StoreConsumerContext {
+export interface StoreContext extends Omit<Logger, "setName">, ComponentContext, StoreConsumerContext {
     /**
      * True while this store is attached to a context that is currently mounted in the view tree.
      */
@@ -23,10 +22,6 @@ export interface StoreContext<Events extends GenericEvents = GenericEvents> exte
      */
     effect(callback: EffectCallback): UnsubscribeFunction;
 }
-type StoreEvents = {
-    mounted: [];
-    unmounted: [];
-};
 export declare class Store<Options, Value> {
     readonly fn: StoreFunction<Options, Value>;
     private _options;
@@ -35,14 +30,14 @@ export declare class Store<Options, Value> {
      */
     value: Value;
     isMounted: boolean;
-    _elementContext: ElementContext;
-    _emitter: Emitter<StoreEvents>;
-    _wildcardListeners: WildcardListenerMap;
-    _logger: Logger;
-    _unsubscribes: UnsubscribeFunction[];
-    _name: string;
-    _id: string;
-    get name(): string;
+    elementContext: ElementContext;
+    lifecycleListeners: {
+        mount: (() => any)[];
+        unmount: (() => any)[];
+    };
+    logger: Logger;
+    id: string;
+    name: string;
     constructor(fn: StoreFunction<Options, Value>, options: Options);
     /**
      * Attaches this Store to the elementContext.
@@ -55,4 +50,3 @@ export declare class Store<Options, Value> {
 export declare function isStore<Options, Value>(value: any): value is Store<Options, Value>;
 export declare class StoreError extends Error {
 }
-export {};

package/dist/core/symbols.d.ts

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

package/dist/http/index.d.ts

@@ -4,7 +4,6 @@
  */
 export declare class HTTP {
     #private;
-    constructor();
     /**
      * Adds a new middleware that will apply to subsequent requests.
      * Returns a function to remove this middleware.