@manyducks.co/dolla 2.0.0-alpha.46 → 2.0.0-alpha.47

package/README.md

@@ -35,31 +35,51 @@ 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.
 
 ```jsx
-import Dolla, { atom } from "@manyducks.co/dolla";
+import Dolla, { $ } from "@manyducks.co/dolla";
 
 function Counter(props, ctx) {
-  const count = atom(0);
+  const count = $(0);
 
+  // An effect will re-run whenever any signal value accessed inside it changes.
   ctx.effect(() => {
-    console.log(`Count is: ${count.get()}`);
+    console.log(`Count is: ${count()}`);
   });
 
   function increment() {
-    count.set(count.get() + 1);
+    // Call signal function with a new value to set it...
+    count(count() + 1);
   }
 
   function decrement() {
-    count.update((value) => value - 1);
-    // alternative to `set(get() - 1)`
+    // ... or pass a function that takes the current value and returns the next.
+    count((value) => value - 1);
   }
 
   return (
     <div>
-      <p>Counter: {counter}</p>
+      {/* Signals can be slotted into the DOM to render them */}
+      <p>Counter: {count}</p>
       <div>
         <button on:click={increment}>+1</button>
         <button on:click={decrement}>-1</button>
       </div>
+
+      {/* We can derive a new signal on the fly and conditionally render something based on that condition */}
+      {when(
+        $(() => count() > 10),
+        <span>That's a lot of clicks!</span>,
+      )}
+
+      {/* ALT: Or slot a getter function into the DOM and have it conditionally render an element */}
+      {() => {
+        // DEV NOTE
+        // If we get Dynamic to track its rendered elements and diff them by keys
+        // then we may be able to do away with repeat and when and just do things like:
+        //    <ul>{() => items().map(item => <li>{item}</li>)}</ul>
+        if (count() > 10) {
+          return <span>That's a lot of clicks!</span>;
+        }
+      }}
     </div>
   );
 }
@@ -71,10 +91,10 @@ Dolla.mount(document.body, Counter);
 
 ```js
 function MessageStore(options, ctx) {
-  const message = atom("Hello world!");
+  const message = $("Hello world!");
 
   ctx.effect(() => {
-    ctx.log(`Message is now: ${get(message)}`);
+    ctx.log(`Message is now: ${message()}`);
     // Calling `get()` inside an effect (or compose) function will track that reactive value as a dependency.
     // Effects will re-run when a dependency updates.
   });
@@ -82,12 +102,8 @@ function MessageStore(options, ctx) {
   // Context objects contain methods for controlling the component, logging and attaching lifecycle hooks.
 
   return {
-    message: compose(() => message.get()),
-    // Creates a read-only reactive of the message value.
-    // Composed values update when their dependencies update.
-
-    setMessage: set(message),
-    // Creates a setter function to update the original message atom.
+    message: $(() => message()),
+    setMessage: (value: string) => message(value),
   };
 }
 

package/dist/core/context.d.ts

@@ -1,6 +1,6 @@
 import type { Dolla } from "./dolla";
 import type { View } from "./nodes/view";
-import type { Atom } from "./signals";
+import type { Source } from "./signals-api";
 import type { Store, StoreFunction } from "./store";
 export interface ElementContext {
     /**
@@ -26,7 +26,7 @@ export interface ElementContext {
     /**
      * Current route layer of the nearest view.
      */
-    route?: Atom<View<{}> | undefined>;
+    route?: Source<View<{}> | undefined>;
 }
 export interface ComponentContext {
     /**

package/dist/core/markup.d.ts

@@ -1,7 +1,7 @@
 import type { Renderable } from "../types.js";
 import type { ElementContext } from "./context.js";
 import { View, type ViewContext, type ViewFunction, type ViewResult } from "./nodes/view.js";
-import { MaybeReactive, type Reactive } from "./signals.js";
+import { type MaybeSignal, type Signal } from "./signals-api.js";
 /**
  * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
  */
@@ -36,28 +36,37 @@ export interface MarkupElement {
 export declare function isMarkup(value: any): value is Markup;
 export declare function isMarkupElement(value: any): value is MarkupElement;
 export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
+export declare enum MarkupType {
+    Text = "$text",
+    Repeat = "$repeat",
+    Dynamic = "$dynamic",
+    Outlet = "$outlet",
+    Fragment = "$fragment",
+    Node = "$node",
+    Portal = "$portal"
+}
 export interface MarkupAttributes {
-    $text: {
+    [MarkupType.Text]: {
         value: any;
     };
-    $list: {
-        items: Reactive<any[]>;
+    [MarkupType.Repeat]: {
+        items: Signal<any[]>;
         keyFn: (value: any, index: number) => string | number | symbol;
-        renderFn: (item: Reactive<any>, index: Reactive<number>, ctx: ViewContext) => ViewResult;
+        renderFn: (item: Signal<any>, index: Signal<number>, ctx: ViewContext) => ViewResult;
     };
-    $dynamic: {
-        source: Reactive<Renderable>;
+    [MarkupType.Dynamic]: {
+        source: Signal<Renderable>;
     };
-    $outlet: {
-        view: Reactive<View<{}> | undefined>;
+    [MarkupType.Outlet]: {
+        view: Signal<View<{}> | undefined>;
     };
-    $fragment: {
-        children: MaybeReactive<MarkupElement[]>;
+    [MarkupType.Fragment]: {
+        children: MaybeSignal<MarkupElement[]>;
     };
-    $node: {
+    [MarkupType.Node]: {
         value: Node;
     };
-    $portal: {
+    [MarkupType.Portal]: {
         content: Renderable;
         parent: Node;
     };
@@ -65,27 +74,19 @@ export interface MarkupAttributes {
 }
 export declare function markup<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
 export declare function markup<I>(type: ViewFunction<I>, attributes?: I, ...children: any[]): Markup;
-/**
- * Generate markup with HTML in a tagged template literal.
- */
-/**
- * Displays content conditionally. When `condition` holds a truthy value, `thenContent` is displayed; when `condition` holds a falsy value, `elseContent` is displayed.
- * @deprecated
- */
-export declare function cond(condition: MaybeReactive<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
 /**
  * Displays `thenContent` when `condition` is truthy and `elseContent` when falsy.
  */
-export declare function when(condition: MaybeReactive<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+export declare function when(condition: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
 /**
  * Inverted `when`. Displays `thenContent` when `condition` is falsy and `elseContent` when truthy.
  */
-export declare function unless(condition: MaybeReactive<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+export declare function unless(condition: MaybeSignal<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 list<T>(items: MaybeReactive<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: (item: Reactive<T>, index: Reactive<number>, ctx: ViewContext) => ViewResult): Markup;
+export declare function repeat<T>(items: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: (item: Signal<T>, index: Signal<number>, ctx: ViewContext) => ViewResult): Markup;
 /**
  * Renders `content` into a `parent` node anywhere in the page, rather than its usual position in the view.
  */

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

@@ -1,10 +1,10 @@
 import type { Renderable } from "../../types.js";
 import type { ElementContext } from "../context.js";
 import { type MarkupElement } from "../markup.js";
-import { type Reactive } from "../signals.js";
+import { Signal } from "../signals-api.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 interface DynamicOptions {
-    source: Reactive<Renderable>;
+    source: Signal<Renderable>;
     elementContext: ElementContext;
 }
 /**

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

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

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

@@ -1,5 +1,5 @@
 import { type MarkupElement } from "../markup.js";
-import { Reactive } from "../signals.js";
+import { type Signal } from "../signals-api.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 import { View } from "./view.js";
 /**
@@ -12,7 +12,7 @@ export declare class Outlet implements MarkupElement {
     private view;
     private mountedView?;
     private unsubscribe?;
-    constructor(view: Reactive<View<{}> | undefined>);
+    constructor(view: Signal<View<{}> | undefined>);
     mount(parent: Node, after?: Node | undefined): void;
     unmount(parentIsUnmounting?: boolean): void;
     private cleanup;

package/dist/core/nodes/{list.d.ts → repeat.d.ts}

@@ -1,15 +1,15 @@
 import { type ElementContext } from "../context.js";
 import { type MarkupElement } from "../markup.js";
-import { type Reactive } from "../signals.js";
+import { type Signal } from "../signals-api.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 import { type ViewContext, type ViewResult } from "./view.js";
-interface ListOptions<T> {
+interface RepeatOptions<T> {
     elementContext: ElementContext;
-    items: Reactive<T[]>;
+    items: Signal<T[]>;
     keyFn: (item: T, index: number) => string | number | symbol;
-    renderFn: (item: Reactive<T>, index: Reactive<number>, ctx: ViewContext) => ViewResult;
+    renderFn: (item: Signal<T>, index: Signal<number>, ctx: ViewContext) => ViewResult;
 }
-export declare class List<T> implements MarkupElement {
+export declare class Repeat<T> implements MarkupElement {
     [IS_MARKUP_ELEMENT]: boolean;
     domNode: Text;
     private items;
@@ -19,7 +19,7 @@ export declare class List<T> implements MarkupElement {
     private renderFn;
     private keyFn;
     get isMounted(): boolean;
-    constructor({ elementContext, items, renderFn, keyFn }: ListOptions<T>);
+    constructor({ elementContext, items, renderFn, keyFn }: RepeatOptions<T>);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
     private _cleanup;

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

@@ -1,12 +1,12 @@
 import type { ComponentContext, ElementContext, StoreConsumerContext, StoreProviderContext } from "../context.js";
 import type { Logger } from "../dolla.js";
 import { type Markup, type MarkupElement } from "../markup.js";
-import { type EffectCallback, type EffectOptions, type Reactive, type UnsubscribeFunction } from "../signals.js";
+import { type Signal, type EffectCallback, type UnsubscribeFunction } from "../signals-api.js";
 import { IS_MARKUP_ELEMENT } from "../symbols.js";
 /**
  * Any valid value that a View can return.
  */
-export type ViewResult = Node | Reactive<any> | Markup | Markup[] | null;
+export type ViewResult = Node | Signal<any> | Markup | Markup[] | null;
 export type ViewFunction<P> = (this: ViewContext, props: P, context: ViewContext) => ViewResult;
 /**
  * A view that has been constructed into DOM nodes.
@@ -43,7 +43,7 @@ export interface ViewContext extends Omit<Logger, "setName">, ComponentContext,
      * Passes a getter function to `callback` that will track reactive states and return their current values.
      * Callback will be run each time a tracked state gets a new value.
      */
-    effect(callback: EffectCallback, options?: EffectOptions): UnsubscribeFunction;
+    effect(callback: EffectCallback): UnsubscribeFunction;
     /**
      * Displays this view's subroutes if mounted as a router view.
      */

package/dist/core/signals-api.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A getter that returns the current value held within the signal.
+ * If called inside a trackable scope this signal will be tracked as a dependency.
+ */
+export interface Signal<T> {
+    (): T;
+}
+/**
+ * Extends Signal with the ability to pass a value or an updater function to change the Signal's value.
+ */
+export interface Source<T> extends Signal<T> {
+    (value: T): void;
+    (updater: (value: T) => T): void;
+}
+export type MaybeSignal<T> = Signal<T> | T;
+export type EqualityFunction<T> = (current: T, next: T) => boolean;
+export interface SignalOptions<T> {
+    /**
+     * A function to compare the current and next values. Returning `true` means the value has changed.
+     */
+    equals?: EqualityFunction<T>;
+}
+export declare function isSource<T>(value: MaybeSignal<T>): value is Source<T>;
+export declare function peek<T>(value: MaybeSignal<T>): T;
+export declare function get<T>(value: MaybeSignal<T>): T;
+/**
+ * Function to be invoked for the effect. Can return an optional cleanup function to be called between invocations.
+ */
+export type EffectCallback = () => void | (() => void);
+export type UnsubscribeFunction = () => void;
+/**
+ * Creates a tracked scope that re-runs whenever the values of any tracked reactives changes.
+ * Reactives are tracked by accessing their `value` within the body of the function.
+ *
+ * NOTE: You must call the unsubscribe function to stop watching for changes.
+ * If you are using an effect inside a View or Store, use `ctx.effect` instead, which cleans up automatically when the component unmounts.
+ */
+export declare function effect(fn: EffectCallback): UnsubscribeFunction;
+export declare function $<T>(compute: () => MaybeSignal<T>, options?: SignalOptions<T>): Signal<T>;
+export declare function $<T>(value: T, options?: SignalOptions<T>): Source<T>;
+export declare function $<T>(value: undefined, options?: SignalOptions<T>): Source<T | undefined>;
+export declare function $<T>(): Source<T | undefined>;

package/dist/core/signals.d.ts

@@ -1,200 +1,22 @@
-import { type Dependency, type Subscriber } from "alien-signals";
+import { type Dependency, type Subscriber, SubscriberFlags } from "alien-signals";
+import type { EqualityFunction } from "./signals-api";
 export interface Effect extends Subscriber, Dependency {
-    fn(): void;
-}
-export interface Computed<T = any> extends Signal<T | undefined>, Subscriber {
-    getter: (cachedValue?: T) => T;
-    equals: EqualityFunction<T>;
-}
-export interface Signal<T = any> extends Dependency {
-    currentValue: T;
-}
-/**
- * A readable reactive state object.
- */
-export interface Reactive<T> {
-    /**
-     * A name provided at the creation of this reactive.
-     */
-    readonly name?: string;
     /**
-     * Returns the current value. Tracks this reactive as a dependency if called within `effect` or `compose`.
+     * Effect function. Can return an optional cleanup callback to be invoked before the next fn() call.
      */
-    get(): T;
-    /**
-     * Returns the current value without tracking this reactive as a dependency when called within `effect` or `compose`.
-     */
-    peek(): T;
-    /**
-     * The current value.
-     * @deprecated use `get()` and `set()`
-     */
-    readonly value: T;
+    fn(): (() => void) | void;
+    cleanup?: () => void;
 }
-export type MaybeReactive<T> = Reactive<T> | T;
-export type UnsubscribeFunction = () => void;
-/**
- * A function to compare the current and next values. Returning `true` means the value has changed.
- */
-export type EqualityFunction<T> = (current: T, next: T) => boolean;
-export interface ReactiveOptions<T> {
-    /**
-     * A label for debugging purposes.
-     */
-    name?: string;
-    /**
-     * A function to compare the current and next values. Returning `true` means the value has changed.
-     */
-    equals?: EqualityFunction<T>;
+export interface Computed<T = any> extends Value<T | undefined>, Subscriber {
+    getter: (cachedValue?: T) => T;
+    equals: EqualityFunction<T>;
 }
-export declare class Atom<T> implements Reactive<T> {
-    #private;
-    get name(): string;
-    get [Symbol.toStringTag](): string;
-    constructor(value: T, options?: ReactiveOptions<T>);
-    /**
-     * Returns the latest value. The signal is tracked as a dependency if called within `effect` or `compose`.
-     */
-    get(): T;
-    /**
-     * Returns the latest value. The signal is NOT tracked if called within `effect` or `compose`.
-     */
-    peek(): T;
-    /**
-     * Replaces the current value with `next`.
-     *
-     * @example
-     * const count = atom(0);
-     * count.set(2);
-     * count.set(count.get() + 1);
-     */
-    set(next: T): void;
-    /**
-     * Passes the current value to `fn` and sets the return value as the next value.
-     *
-     * @example
-     * const count = atom(0);
-     * count.update((current) => current + 1);
-     * count.update((current) => current * 5);
-     *
-     * // Also works very well with Immer `produce` for complex objects.
-     * const items = atom([{ name: "Alice", age: 26 }, { name: "Bob", age: 33 }]);
-     *
-     * // Without Immer:
-     * items.update((current) => {
-     *   // Return a new array with Bob's age increased by 1.
-     *   const newItems = [...current];
-     *   newItems[1] = {
-     *     ...newItems[1],
-     *     age: newItems[1].age + 1
-     *   };
-     *   return newItems;
-     * });
-     *
-     * // With Immer:
-     * import { produce } from "immer";
-     *
-     * items.update(produce((draft) => {
-     *   // Mutate draft to increase Bob's age by 1.
-     *   // Results in a new object with this patch applied.
-     *   draft[1].age++;
-     * }));
-     */
-    update(fn: (current: T) => T): void;
-    /**
-     * @deprecated use `get()`
-     */
-    get value(): T;
-    /**
-     * @deprecated use `set()`
-     */
-    set value(next: T);
+export interface Value<T = any> extends Dependency {
+    current: T;
 }
-/**
- * Determines if a value is reactive.
- */
-export declare function isReactive<T>(value: any): value is Reactive<T>;
-/**
- * Creates a simple reactive container that stores a value.
- * Atom values can be read and updated with the `value` property
- *
- * @example
- * const count = atom<number>();
- * count.set(5);
- * count.get(); // 5
- */
-export declare function atom<T>(): Atom<T | undefined>;
-/**
- * Creates a simple reactive container that stores a value.
- * Atom values can be read and updated with the `value` property.
- *
- * @example
- * const count = atom(1);
- * count.set(count.get() + 1);
- * count.get(); // 2
- */
-export declare function atom<T>(value: T, options?: ReactiveOptions<T>): Atom<T>;
-/**
- * Creates a simple reactive container that stores a value.
- * Atom values can be read and updated with the `value` property.
- *
- * @example
- * const count = atom(1);
- * count.value++;
- * count.value; // 2
- */
-export declare function atom<T>(value?: T, options?: ReactiveOptions<T>): Atom<T | undefined>;
-type ComposeCallback<T> = (previousValue?: T) => MaybeReactive<T>;
-/**
- * Creates a reactive container that derives its value from other reactive values that it tracks.
- *
- * @example
- * const count = atom(1);
- * const doubled = compose(() => count.get() * 2);
- */
-export declare function compose<T>(fn: ComposeCallback<T>, options?: ReactiveOptions<T>): Reactive<T>;
-/**
- * Takes a new value to set, or a callback that receives the current value and returns a new value to set.
- */
-type Setter<T> = (next: T | ((current: T) => T)) => void;
-export declare function set<T>(atom: Atom<T>): Setter<T>;
-export declare function set<T>(atom: Atom<T>, next: T | ((current: T) => T)): void;
-/**
- * Returns the current value from a reactive _and track it_ if called in a `compose` or `effect` scope.
- * If a non-reactive value is passed it will just be returned untracked.
- *
- * @example
- * const count = atom(1);
- * const value = get(count); // 1
- *
- * const value = get(5); // 5
- */
-export declare function get<T>(value: MaybeReactive<T>): T;
-/**
- * Returns the current value from a reactive (without tracking).
- * If a non-reactive value is passed it will be returned.
- *
- * @example
- * ctx.effect(() => {
- *   const doubled = get(count) * 2; // `count` will be tracked
- *
- *   const doubled = peek(count) * 2; // `count` will NOT be tracked
- * });
- */
-export declare function peek<T>(value: MaybeReactive<T>): T;
-export declare function untrack(fn: () => void): void;
-/**
- * Registers a callback that will receive a list of dependencies that were tracked within the scope this function was called in.
- */
-export declare function getTracked(fn: (tracked: Reactive<unknown>[]) => void): void;
-export type EffectCallback = () => void;
-export type EffectOptions = {};
-/**
- * Creates a tracked scope that re-runs whenever the values of any tracked reactives changes.
- * Reactives are tracked by accessing their `value` within the body of the function.
- *
- * NOTE: You must call the unsubscribe function to stop watching for changes.
- * If you are using an effect inside a View or Store, use `ctx.effect` instead, which cleans up automatically when the component unmounts.
- */
-export declare function effect(fn: EffectCallback, options?: EffectOptions): UnsubscribeFunction;
-export {};
+export declare const link: (dep: Dependency, sub: Subscriber) => import("alien-signals").Link | undefined, propagate: (link: import("alien-signals").Link) => void, updateDirtyFlag: (sub: Subscriber, flags: SubscriberFlags) => boolean, startTracking: (sub: Subscriber) => void, endTracking: (sub: Subscriber) => void, processEffectNotifications: () => void, processComputedUpdate: (computed: Dependency & Subscriber, flags: SubscriberFlags) => void, processPendingInnerEffects: (sub: Subscriber, flags: SubscriberFlags) => void;
+export declare let activeSub: Subscriber | undefined;
+export declare function queueEffect(e: Effect): void;
+export declare function stopEffect(this: Effect): void;
+export declare function pauseTracking(): void;
+export declare function resumeTracking(): void;

package/dist/core/store.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentContext, ElementContext, StoreConsumerContext } from "./context.js";
 import type { Logger } from "./dolla.js";
-import { type EffectCallback, type EffectOptions, type UnsubscribeFunction } from "./signals.js";
+import { type EffectCallback, type UnsubscribeFunction } from "./signals-api.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 extends Omit<Logger, "setName">, ComponentContext, StoreConsumerContext {
@@ -20,7 +20,7 @@ export interface StoreContext extends Omit<Logger, "setName">, ComponentContext,
      * Passes a getter function to `callback` that will track reactive states and return their current values.
      * Callback will be run each time a tracked state gets a new value.
      */
-    effect(callback: EffectCallback, options?: EffectOptions): UnsubscribeFunction;
+    effect(callback: EffectCallback): UnsubscribeFunction;
 }
 export declare class Store<Options, Value> {
     readonly fn: StoreFunction<Options, Value>;

package/dist/fragment-vl5kFl1d.js

@@ -0,0 +1,8 @@
+import { m } from "./markup-B-2w-v-S.js";
+function a(r, n) {
+  return m("$dynamic", { source: () => r.children });
+}
+export {
+  a as F
+};
+//# sourceMappingURL=fragment-vl5kFl1d.js.map

package/dist/fragment-vl5kFl1d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment-vl5kFl1d.js","sources":["../src/core/views/fragment.ts"],"sourcesContent":["import type { Renderable } from \"../../types.js\";\nimport { markup } from \"../markup.js\";\nimport { type ViewContext } from \"../nodes/view.js\";\n\n/**\n * A utility view that displays its children.\n */\nexport function Fragment(props: { children?: Renderable }, ctx: ViewContext) {\n  return markup(\"$dynamic\", { source: () => props.children });\n}\n"],"names":["Fragment","props","ctx","markup"],"mappings":";AAOgB,SAAAA,EAASC,GAAkCC,GAAkB;AAC3E,SAAOC,EAAO,YAAY,EAAE,QAAQ,MAAMF,EAAM,UAAU;AAC5D;"}

package/dist/index.d.ts

@@ -1,15 +1,15 @@
-export { atom, compose, effect, get, getTracked, peek, set, untrack } from "./core/signals.js";
-export type { Atom, MaybeReactive, Reactive } from "./core/signals.js";
+export { $, effect, get, peek } from "./core/signals-api.js";
+export type { MaybeSignal, Signal, Source } from "./core/signals-api.js";
 export { deepEqual, shallowEqual, strictEqual } from "./utils.js";
-export { ref, type Ref } from "./core/ref.js";
 export { type StoreContext, type StoreFunction } from "./core/store.js";
 export { createRouter, type Router, type RouterOptions } from "./router/index.js";
-export { cond, list, markup, portal, unless, when } from "./core/markup.js";
+export { markup, portal, repeat, unless, when } from "./core/markup.js";
 export type { Markup, MarkupElement } from "./core/markup.js";
 import { Dolla } from "./core/dolla.js";
 declare const dolla: Dolla;
 export default dolla;
-export declare const t: (selector: string, options?: import("./translate/index.js").TOptions) => import("./core/signals.js").Reactive<string>;
+export declare const t: (selector: string, options?: import("./translate/index.js").TOptions) => import("./core/signals-api.js").Signal<string>;
+export declare const i18n: import("./translate/index.js").I18n;
 export declare const http: import("./http/index.js").HTTP;
 export declare const createLogger: (name: string, options?: import("./core/dolla.js").LoggerOptions) => import("./core/dolla.js").Logger;
 export type { Dolla, Environment, Logger, LoggerErrorContext, LoggerOptions, Loggles } from "./core/dolla.js";