@manyducks.co/dolla 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/jsx-dev-runtime.js

@@ -1,5 +1,5 @@
-import { r as s } from "./passthrough-BSLd3foL.js";
-import { P as m } from "./passthrough-BSLd3foL.js";
+import { r as s } from "./passthrough-CW8Ezjg-.js";
+import { P as m } from "./passthrough-CW8Ezjg-.js";
 function d(n, r, t, e, a, l) {
   const i = { ...o(["children", "key"], r) }, c = Array.isArray(r.children) ? r.children : [r.children];
   return s(n, i, ...c);

package/dist/jsx-runtime.js

@@ -1,5 +1,5 @@
-import { r as t } from "./passthrough-BSLd3foL.js";
-import { P as l } from "./passthrough-BSLd3foL.js";
+import { r as t } from "./passthrough-CW8Ezjg-.js";
+import { P as l } from "./passthrough-CW8Ezjg-.js";
 function d(n, e, r) {
   return t(n, e ? { ...u(["children", "key"], e) } : void 0, e.children);
 }

package/dist/markup.d.ts

@@ -1,5 +1,5 @@
 import type { Dolla } from "./modules/dolla.js";
-import { MaybeSignal, type Signal } from "./signals.js";
+import { MaybeState, type State } from "./state.js";
 import type { Renderable, Stringable } from "./types.js";
 import { type ViewFunction, type ViewContext, type ViewResult } from "./view.js";
 export interface ElementContext {
@@ -34,24 +34,24 @@ export declare function isNode(value: unknown): value is MarkupNode;
 export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
 export interface MarkupAttributes {
     $text: {
-        value: MaybeSignal<Stringable>;
+        value: MaybeState<Stringable>;
     };
     $cond: {
-        $predicate: Signal<any>;
+        $predicate: State<any>;
         thenContent?: Renderable;
         elseContent?: Renderable;
     };
     $repeat: {
-        $items: Signal<any[]>;
+        $items: State<any[]>;
         keyFn: (value: any, index: number) => string | number | symbol;
-        renderFn: ($item: Signal<any>, $index: Signal<number>, c: ViewContext) => ViewResult;
+        renderFn: ($item: State<any>, $index: State<number>, c: ViewContext) => ViewResult;
     };
     $observer: {
-        signals: Signal<any>[];
+        states: State<any>[];
         renderFn: (...items: any) => Renderable;
     };
     $outlet: {
-        $children: Signal<MarkupNode[]>;
+        $children: State<MarkupNode[]>;
     };
     $node: {
         value: Node;
@@ -71,22 +71,22 @@ export declare const html: (strings: TemplateStringsArray, ...values: any[]) =>
 /**
  * Displays content conditionally. When `predicate` holds a truthy value, `thenContent` is displayed; when `predicate` holds a falsy value, `elseContent` is displayed.
  */
-export declare function cond(predicate: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+export declare function cond(predicate: 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.
  */
-export declare function repeat<T>(items: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult): Markup;
+export declare function repeat<T>(items: MaybeState<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult): Markup;
 /**
  * Render `content` into a `parent` node anywhere in the page, rather than at its position in the view.
  */
 export declare function portal(parent: Node, content: Renderable): Markup;
 /**
- * A special kind of signal exclusively for storing references to DOM nodes.
+ * A special kind of State exclusively for storing references to DOM nodes.
  */
 export declare function createRef<T extends Node>(): Ref<T>;
 export declare function isRef<T extends Node>(value: any): value is Ref<T>;
-export interface Ref<T extends Node> extends Signal<T | undefined> {
+export interface Ref<T extends Node> extends State<T | undefined> {
     node: T | undefined;
 }
 /**

package/dist/modules/dolla.d.ts

@@ -1,5 +1,5 @@
 import { createRef, isRef, MarkupNode, type Markup } from "../markup.js";
-import { createSettableSignal, createSignal, derive, designalify, signalify, toSettableSignal, watch, type Signal } from "../signals.js";
+import { createSettableState, createState, derive, toSettableState, toState, valueOf, watch, type State } from "../state.js";
 import { type ViewFunction, type ViewNode } from "../view.js";
 import { type CrashViewProps } from "../views/default-crash-view.js";
 import { HTTP } from "./http.js";
@@ -45,11 +45,11 @@ export declare class Dolla {
     readonly render: Render;
     readonly router: Router;
     constructor();
-    createSignal: typeof createSignal;
-    createSettableSignal: typeof createSettableSignal;
-    toSettableSignal: typeof toSettableSignal;
-    signalify: typeof signalify;
-    designalify: typeof designalify;
+    createState: typeof createState;
+    createSettableState: typeof createSettableState;
+    toSettableState: typeof toSettableState;
+    toState: typeof toState;
+    valueOf: typeof valueOf;
     derive: typeof derive;
     watch: typeof watch;
     createRef: typeof createRef;
@@ -99,7 +99,7 @@ export declare class Dolla {
      */
     setLoggles(options: Partial<Loggles>): void;
     setLogFilter(filter: string | RegExp): void;
-    createLogger(name: string | Signal<string>, options?: LoggerOptions): Logger;
+    createLogger(name: string | State<string>, options?: LoggerOptions): Logger;
     /**
      *
      */

package/dist/modules/language.d.ts

@@ -1,4 +1,4 @@
-import { type Signal } from "../signals.js";
+import { type State } from "../state.js";
 import type { Stringable } from "../types.js";
 import type { Dolla } from "./dolla.js";
 /**
@@ -25,17 +25,17 @@ export type LanguageSetupOptions = {
 };
 export declare class Language {
     #private;
-    $current: Signal<string | undefined>;
+    $current: State<string | undefined>;
     constructor(dolla: Dolla);
     get supportedLanguages(): string[];
     setup(options: LanguageSetupOptions): void;
     setLanguage(name: string): Promise<void>;
     /**
-     * Returns a Signal containing the value at `key`.
+     * Returns a State containing the value at `key`.
     
      * @param key - Key to the translated value.
      * @param values - A map of {{placeholder}} names and the values to replace them with.
      */
-    t(key: string, values?: Record<string, Stringable | Signal<Stringable>>): Signal<string>;
+    t(key: string, values?: Record<string, Stringable | State<Stringable>>): State<string>;
 }
 export {};

package/dist/modules/router.d.ts

@@ -107,19 +107,19 @@ export declare class Router {
     /**
      * The currently matched route pattern, if any.
      */
-    $pattern: import("../signals.js").Signal<string | null>;
+    $pattern: import("../state.js").State<string | null>;
     /**
      * The current URL path.
      */
-    $path: import("../signals.js").Signal<string>;
+    $path: import("../state.js").State<string>;
     /**
      * The current named path params.
      */
-    $params: import("../signals.js").Signal<ParsedParams>;
+    $params: import("../state.js").State<ParsedParams>;
     /**
      * The current query params. Changes to this object will be reflected in the URL.
      */
-    $query: import("../signals.js").Signal<ParsedQuery>;
+    $query: import("../state.js").State<ParsedQuery>;
     constructor(dolla: Dolla, elements: RouterElements);
     setup(options: RouterSetupOptions): void;
     /**

package/dist/nodes/cond.d.ts

@@ -1,8 +1,8 @@
 import { type MarkupNode, type ElementContext, type Markup } from "../markup.js";
-import { type Signal, type StopFunction } from "../signals.js";
+import { type State, type StopFunction } from "../state.js";
 import { type Renderable } from "../types.js";
 export interface ConditionalConfig {
-    $predicate: Signal<any>;
+    $predicate: State<any>;
     thenContent?: Renderable;
     elseContent?: Renderable;
     elementContext: ElementContext;
@@ -10,7 +10,7 @@ export interface ConditionalConfig {
 export declare class Conditional implements MarkupNode {
     node: Node;
     endNode: Node;
-    $predicate: Signal<any>;
+    $predicate: State<any>;
     stopCallback?: StopFunction;
     thenContent?: Markup[];
     elseContent?: Markup[];

package/dist/nodes/html.d.ts

@@ -1,5 +1,5 @@
 import { type MarkupNode, type ElementContext, type Markup, type Ref } from "../markup.js";
-import { type StopFunction } from "../signals.js";
+import { type StopFunction } from "../state.js";
 type HTMLOptions = {
     elementContext: ElementContext;
     tag: string;

package/dist/nodes/observer.d.ts

@@ -1,9 +1,9 @@
-import { type MarkupNode, type ElementContext } from "../markup.js";
-import { type Signal } from "../signals.js";
+import { type ElementContext, type MarkupNode } from "../markup.js";
+import { type State } from "../state.js";
 import type { Renderable } from "../types.js";
 interface ObserverOptions {
     elementContext: ElementContext;
-    signals: Signal<any>[];
+    states: State<any>[];
     renderFn: (...values: any) => Renderable;
 }
 /**
@@ -20,7 +20,7 @@ export declare class Observer implements MarkupNode {
         stop: () => void;
     };
     get isMounted(): boolean;
-    constructor({ signals, renderFn, elementContext }: ObserverOptions);
+    constructor({ states, renderFn, elementContext }: ObserverOptions);
     mount(parent: Node, after?: Node): void;
     unmount(): void;
     cleanup(): void;

package/dist/nodes/outlet.d.ts

@@ -1,7 +1,7 @@
 import { type MarkupNode, type ElementContext } from "../markup.js";
-import { type Signal, type StopFunction } from "../signals.js";
+import { type State, type StopFunction } from "../state.js";
 export interface OutletConfig {
-    $children: Signal<MarkupNode[]>;
+    $children: State<MarkupNode[]>;
     elementContext: ElementContext;
 }
 /**
@@ -10,7 +10,7 @@ export interface OutletConfig {
 export declare class Outlet implements MarkupNode {
     node: Node;
     endNode: Node;
-    $children: Signal<MarkupNode[]>;
+    $children: State<MarkupNode[]>;
     stopCallback?: StopFunction;
     connectedChildren: MarkupNode[];
     elementContext: ElementContext;

package/dist/nodes/repeat.d.ts

@@ -1,28 +1,28 @@
 import { type MarkupNode, type ElementContext } from "../markup.js";
-import { type Signal, type SignalSetter, type StopFunction } from "../signals.js";
+import { type State, type Setter, type StopFunction } from "../state.js";
 import { type ViewContext, type ViewResult } from "../view.js";
 interface RepeatOptions<T> {
     elementContext: ElementContext;
-    $items: Signal<T[]>;
+    $items: State<T[]>;
     keyFn: (value: T, index: number) => string | number | symbol;
-    renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult;
+    renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult;
 }
 type ConnectedItem<T> = {
     key: any;
-    $value: Signal<T>;
-    setValue: SignalSetter<T>;
-    $index: Signal<number>;
-    setIndex: SignalSetter<number>;
+    $value: State<T>;
+    setValue: Setter<T>;
+    $index: State<number>;
+    setIndex: Setter<number>;
     handle: MarkupNode;
 };
 export declare class Repeat<T> implements MarkupNode {
     node: Node;
     endNode: Node;
-    $items: Signal<T[]>;
+    $items: State<T[]>;
     stopCallback?: StopFunction;
     connectedItems: ConnectedItem<T>[];
     elementContext: ElementContext;
-    renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult;
+    renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult;
     keyFn: (value: T, index: number) => string | number | symbol;
     get isMounted(): boolean;
     constructor({ elementContext, $items, renderFn, keyFn }: RepeatOptions<T>);

package/dist/nodes/text.d.ts

@@ -1,14 +1,14 @@
 import { type MarkupNode } from "../markup.js";
-import { type MaybeSignal, type StopFunction } from "../signals.js";
+import { type MaybeState, type StopFunction } from "../state.js";
 interface Stringable {
     toString(): string;
 }
 interface TextOptions {
-    value: MaybeSignal<Stringable>;
+    value: MaybeState<Stringable>;
 }
 export declare class Text implements MarkupNode {
     node: globalThis.Text;
-    value: MaybeSignal<Stringable>;
+    value: MaybeState<Stringable>;
     stopCallback?: StopFunction;
     get isMounted(): boolean;
     constructor({ value }: TextOptions);