@manyducks.co/dolla 0.69.2 → 0.69.4

package/lib/nodes/text.d.ts

@@ -1,5 +1,5 @@
-import { type Readable, type StopFunction } from "../state.js";
 import { type DOMHandle } from "../markup.js";
+import { type Readable, type StopFunction } from "../state.js";
 interface Stringable {
     toString(): string;
 }

package/lib/routing.d.ts

@@ -0,0 +1,79 @@
+export type RouteMatch<T = Record<string, any>> = {
+    /**
+     * The path string that triggered this match.
+     */
+    path: string;
+    /**
+     * The pattern satisfied by `path`.
+     */
+    pattern: string;
+    /**
+     * Named params as parsed from `path`.
+     */
+    params: Record<string, string | number>;
+    /**
+     * Query params as parsed from `path`.
+     */
+    query: Record<string, string | number | boolean>;
+    /**
+     * Metadata registered to this route.
+     */
+    meta: T;
+};
+export declare enum FragTypes {
+    Literal = 1,
+    Param = 2,
+    Wildcard = 3,
+    NumericParam = 4
+}
+export type RouteFragment = {
+    name: string;
+    type: FragTypes;
+    value: string | number | null;
+};
+export type Route<T> = {
+    pattern: string;
+    fragments: RouteFragment[];
+    meta: T;
+};
+export type RouteMatchOptions<T> = {
+    willMatch?: (route: Route<T>) => boolean;
+};
+/**
+ * Separates a URL path into multiple fragments.
+ *
+ * @param path - A path string (e.g. `"/api/users/5"`)
+ * @returns an array of fragments (e.g. `["api", "users", "5"]`)
+ */
+export declare function splitPath(path: string): string[];
+/**
+ * Joins multiple URL path fragments into a single string.
+ *
+ * @param parts - One or more URL fragments (e.g. `["api", "users", 5]`)
+ * @returns a joined path (e.g. `"api/users/5"`)
+ */
+export declare function joinPath(parts: {
+    toString(): string;
+}[]): string;
+export declare function resolvePath(base: string, part: string | null): string;
+export declare function parseQueryParams(query: string): Record<string, string | number | boolean>;
+/**
+ * Returns the nearest match, or undefined if the path matches no route.
+ *
+ * @param url - Path to match against routes.
+ * @param options - Options to customize how matching operates.
+ */
+export declare function matchRoutes<T>(routes: Route<T>[], url: string, options?: RouteMatchOptions<T>): RouteMatch<T> | undefined;
+/**
+ * Sort routes descending by specificity. Guarantees that the most specific route matches first
+ * no matter the order in which they were added.
+ *
+ * Routes without named params and routes with more fragments are weighted more heavily.
+ */
+export declare function sortRoutes<T>(routes: Route<T>[]): Route<T>[];
+/**
+ * Converts a route pattern into a set of matchable fragments.
+ *
+ * @param route - A route string (e.g. "/api/users/{id}")
+ */
+export declare function patternToFragments(pattern: string): RouteFragment[];

package/lib/routing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/state.d.ts

@@ -98,5 +98,5 @@ export declare function observe<I1, I2, I3, I4, I5, I6, I7>(state1: MaybeReadabl
 export declare function observe<I1, I2, I3, I4, I5, I6, I7, I8>(state1: MaybeReadable<I1>, state2: MaybeReadable<I2>, state3: MaybeReadable<I3>, state4: MaybeReadable<I4>, state5: MaybeReadable<I5>, state6: MaybeReadable<I6>, state7: MaybeReadable<I7>, state8: MaybeReadable<I8>, callback: (value1: I1, value2: I2, value3: I3, value4: I4, value5: I5, value6: I6, value7: I7, value8: I8) => void): StopFunction;
 export declare function observe<I1, I2, I3, I4, I5, I6, I7, I8, I9>(state1: MaybeReadable<I1>, state2: MaybeReadable<I2>, state3: MaybeReadable<I3>, state4: MaybeReadable<I4>, state5: MaybeReadable<I5>, state6: MaybeReadable<I6>, state7: MaybeReadable<I7>, state8: MaybeReadable<I8>, state9: MaybeReadable<I9>, callback: (value1: I1, value2: I2, value3: I3, value4: I4, value5: I5, value6: I6, value7: I7, value8: I8, value9: I9) => void): StopFunction;
 export declare function observe<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>(state1: MaybeReadable<I1>, state2: MaybeReadable<I2>, state3: MaybeReadable<I3>, state4: MaybeReadable<I4>, state5: MaybeReadable<I5>, state6: MaybeReadable<I6>, state7: MaybeReadable<I7>, state8: MaybeReadable<I8>, state9: MaybeReadable<I9>, state10: MaybeReadable<I10>, callback: (value1: I1, value2: I2, value3: I3, value4: I4, value5: I5, value6: I6, value7: I7, value8: I8, value9: I9, value10: I10) => void): StopFunction;
-export declare function unwrap<T>(value: Readable<T> | T): T;
+export declare function unwrap<T>(value: MaybeReadable<T>): T;
 export {};

package/lib/store.d.ts

@@ -1,6 +1,6 @@
 import { type AppContext, type ElementContext } from "./app.js";
 import { type DebugChannel } from "./classes/DebugHub.js";
-import { MaybeReadable, type ReadableValues } from "./state.js";
+import { type MaybeReadable, type ReadableValues } from "./state.js";
 import type { BuiltInStores } from "./types.js";
 export type Store<O, E> = (context: StoreContext<O>) => E | Promise<E>;
 export interface StoreContext<Options = any> extends DebugChannel {

package/lib/typeChecking.d.ts

@@ -0,0 +1,191 @@
+type TypeNames = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "null" | "array" | "class" | "promise" | "NaN";
+/**
+ * Extends `typeof` operator with more specific and useful type distinctions.
+ */
+export declare function typeOf(value: unknown): TypeNames;
+/**
+ * Throws a TypeError unless `condition` is truthy.
+ *
+ * @param condition - Value whose truthiness is in question.
+ * @param errorMessage - Optional message for the thrown TypeError.
+ */
+export declare function assert(condition: any, errorMessage?: string): void;
+/**
+ * Returns true if `value` is an array.
+ */
+export declare function isArray(value: unknown): value is Array<unknown>;
+/**
+ * Throws an error if `value` is not an array.
+ */
+export declare function assertArray(value: unknown, errorMessage?: string): value is Array<unknown>;
+/**
+ * Returns a function that takes a `value` and ensures that it is an array for which `check` returns true for every item.
+ *
+ * @param check - Function to check items against.
+ */
+export declare function isArrayOf<T>(check: (item: unknown) => boolean): (value: unknown) => value is T[];
+/**
+ * Returns true when `value` is an array and `check` returns true for every item.
+ *
+ * @param check - Function to check items against.
+ * @param value - A possible array.
+ */
+export declare function isArrayOf<T>(check: (item: unknown) => boolean, value: unknown): value is T[];
+/**
+ * Returns a function that takes a `value` and throws a TypeError unless it is an array for which `check` returns true for every item.
+ *
+ * @param check - Function to check items against.
+ */
+export declare function assertArrayOf<T>(check: (item: unknown) => boolean): (value: unknown) => value is T[];
+/**
+ * Throws a TypeError unless `value` is an array and `check` returns true for every item.
+ *
+ * @param check - Function to check items against.
+ * @param value - A possible array.
+ * @param errorMessage - A custom error message.
+ */
+export declare function assertArrayOf<T>(check: (item: unknown) => boolean, value: unknown, errorMessage?: string): value is T[];
+/**
+ * Returns true if `value` is equal to `true` or `false`.
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Throws a TypeError unless `value` is equal to `true` or `false`.
+ */
+export declare function assertBoolean(value: unknown, errorMessage?: string): value is boolean;
+/**
+ * Returns true if `value` is a string.
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Throws a TypeError unless `value` is a string.
+ */
+export declare function assertString(value: unknown, errorMessage?: string): value is string;
+/**
+ * Returns true if `value` is a function (but not a class).
+ */
+export declare function isFunction<T = (...args: unknown[]) => unknown>(value: unknown): value is T;
+/**
+ * Throws a TypeError unless `value` is a function.
+ */
+export declare function assertFunction<T = (...args: unknown[]) => unknown>(value: unknown, errorMessage?: string): value is T;
+/**
+ * Returns true if `value` is a number.
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Throws a TypeError unless `value` is a number.
+ */
+export declare function assertNumber(value: unknown, errorMessage?: string): value is number;
+/**
+ * Returns true if `value` implements the Promise protocol.
+ * This matches true instances of Promise as well as any object that
+ * implements `next`, `catch` and `finally` methods.
+ *
+ * To strictly match instances of Promise, use `isInstanceOf(Promise)`.
+ */
+export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
+/**
+ * Throws a TypeError unless `value` implements the Promise protocol.
+ * This matches true instances of Promise as well as any object that
+ * implements `next`, `catch` and `finally` methods.
+ *
+ * To strictly allow only instances of Promise, use `Type.assertInstanceOf(Promise)`.
+ */
+export declare function assertPromise<T = unknown>(value: unknown, errorMessage?: string): value is Promise<T>;
+/**
+ * Returns true if `value` is a class.
+ */
+export declare function isClass(value: unknown): value is {
+    new (): unknown;
+};
+/**
+ * Throws a TypeError unless `value` is a class.
+ */
+export declare function assertClass(value: unknown, errorMessage?: string): value is {
+    new (): unknown;
+};
+/**
+ * Returns a function that takes a `value` and returns true if `value` is an instance of `constructor`.
+ *
+ * @param constructor - The constructor a value must be an instance of to match.
+ */
+export declare function isInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;
+/**
+ * Returns `true` if `value` is an instance of `constructor`.
+ *
+ * @param constructor - The constructor `value` must be an instance of.
+ * @param value - A value that may be an instance of `constructor`.
+ */
+export declare function isInstanceOf<T extends Function>(constructor: T, value: unknown): value is T;
+/**
+ * Returns a function that takes a `value` and throws a TypeError unless `value` is an instance of `constructor`.
+ *
+ * @param constructor - The constructor a value must be an instance of to match.
+ */
+export declare function assertInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;
+/**
+ * Throws a TypeError unless `value` is an instance of `constructor`.
+ *
+ * @param constructor - The constructor `value` must be an instance of.
+ * @param value - A value that may be an instance of `constructor`.
+ * @param errorMessage - A custom error message for when the assertion fails.
+ */
+export declare function assertInstanceOf<T extends Function>(constructor: T, value: unknown, errorMessage?: string): value is T;
+/**
+ * Returns true if `value` is a Map.
+ */
+export declare function isMap<K = unknown, V = unknown>(value: any): value is Map<K, V>;
+/**
+ * Throws a TypeError unless `value` is a Map.
+ */
+export declare function assertMap<K = unknown, V = unknown>(value: any, errorMessage?: string): value is Map<K, V>;
+/**
+ * Returns true if `value` is a Set.
+ */
+export declare function isSet<T = unknown>(value: any): value is Set<T>;
+/**
+ * Throws a TypeError if `value` is not a Set.
+ */
+export declare function assertSet<T = unknown>(value: any, errorMessage?: string): value is Set<T>;
+/**
+ * Returns true if `value` implements the Iterable protocol.
+ */
+export declare function isIterable<T>(value: any): value is Iterable<T>;
+/**
+ * Throws a TypeError unless `value` implements the Iterable protocol.
+ */
+export declare function assertIterable<T>(value: any, errorMessage?: string): value is Iterable<T>;
+/**
+ * Returns true if `value` is a plain JavaScript object.
+ */
+export declare function isObject(value: unknown): value is Record<string | number | symbol, unknown>;
+/**
+ * Throws a TypeError unless `value` is a plain JavaScript object.
+ */
+export declare function assertObject(value: unknown, errorMessage?: string): value is object;
+/**
+ * Returns true if `value` is equal to `null`.
+ */
+export declare function isNull(value: unknown): value is null;
+/**
+ * Throws a TypeError unless `value` is equal to `null`.
+ */
+export declare function assertNull(value: unknown, errorMessage?: string): value is null;
+/**
+ * Returns true if `value` is equal to `undefined`.
+ */
+export declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Throws a TypeError unless `value` is equal to `undefined`.
+ */
+export declare function assertUndefined(value: unknown, errorMessage?: string): value is undefined;
+/**
+ * Returns true if `value` is equal to `null` or `undefined`.
+ */
+export declare function isEmpty(value: unknown): value is void;
+/**
+ * Throws a TypeError unless `value` is equal to `null` or `undefined`.
+ */
+export declare function assertEmpty(value: unknown, errorMessage?: string): value is void;
+export {};

package/lib/types.d.ts

@@ -3,7 +3,7 @@ import { type Markup } from "./markup.js";
 import { type Readable, type Writable } from "./state.js";
 import { type Store } from "./store.js";
 import { type DocumentStore } from "./stores/document.js";
-import { RenderStore } from "./stores/render.js";
+import { type RenderStore } from "./stores/render.js";
 /**
  * Value will be read by the component.
  */

package/notes/views.md

@@ -1,5 +1,5 @@
 ```js
-import { View, Store, State } from "@manyducks.co/dolla";
+import { View, Store, $, $$ } from "@manyducks.co/dolla";
 
 const SomeView = View("SomeView")
   .props((t) => ({
@@ -13,16 +13,10 @@ const SomeView = View("SomeView")
   });
 
 const SomeStore = Store("SomeStore").build((ctx) => {
-  const $$value = State(0);
+  const $$value = $$(0);
 
   return {
-    $value: $$value.readable(),
+    $value: $($$value),
   };
 });
-
-// Stores can be configured in an app like so:
-
-const app = App();
-
-app.addStore(SomeStore.configure(options));
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manyducks.co/dolla",
-  "version": "0.69.2",
+  "version": "0.69.4",
   "description": "Front-end components, routing and state management.",
   "main": "lib/index.js",
   "types": "./index.d.ts",
@@ -8,7 +8,7 @@
   "sideEffects": false,
   "repository": "https://github.com/manyducksco/dolla",
   "scripts": {
-    "test": "tsc && node --test",
+    "test": "npm run build && node --test",
     "build": "tsc && node build.js",
     "start": "tsc --watch",
     "prepublishOnly": "NODE_ENV=production npm run build"
@@ -39,18 +39,17 @@
     }
   },
   "dependencies": {
-    "@borf/bedrock": "^3.1.0",
     "fetch-ponyfill": "^7.1.0",
     "history": "^5.3.0",
-    "nanoid": "^4.0.2",
+    "nanoid": "^5.0.4",
     "simple-color-hash": "^1.0.2"
   },
   "devDependencies": {
     "@types/node": "^18.17.6",
-    "csstype": "^3.1.2",
-    "esbuild": "^0.19.2",
-    "prettier": "^2.8.8",
-    "typescript": "^5.2.2",
-    "zod": "^3.22.2"
+    "csstype": "^3.1.3",
+    "esbuild": "^0.20.0",
+    "prettier": "^3.2.4",
+    "typescript": "^5.3.3",
+    "zod": "^3.22.4"
   }
 }

package/tests/state.test.js

@@ -1,11 +1,11 @@
 import test from "node:test";
 import assert from "node:assert";
-import { proxy, observe, readable, writable, computed, unwrap, isReadable, isWritable } from "../lib/index.js";
+import { $, $$, observe, unwrap, isReadable, isWritable } from "../lib/index.js";
 
 test("isReadable, isWritable: returns correct results", (t) => {
-  const $$writable = writable(5);
-  const $readable = readable($$writable);
-  const $computed = computed($readable, (x) => x * 2);
+  const $$writable = $$(5);
+  const $readable = $($$writable);
+  const $computed = $($readable, (x) => x * 2);
 
   assert.strictEqual(isWritable($$writable), true);
   assert.strictEqual(isReadable($$writable), true);
@@ -18,16 +18,16 @@ test("isReadable, isWritable: returns correct results", (t) => {
 });
 
 test("readable, writable, computed: basic functionality", (t) => {
-  const $$writable = writable("writable");
-  const $readable = readable("test");
-  const $x = computed($readable, (v) => v.toUpperCase());
-  const $y = readable($$writable);
+  const $$writable = $$("writable");
+  const $readable = $("test");
+  const $x = $($readable, (v) => v.toUpperCase());
+  const $y = $($$writable);
 
-  const compute = t.mock.fn(([x, y]) => {
+  const compute = t.mock.fn((x, y) => {
     return x + y;
   });
 
-  const $computed = computed([$x, $y], compute);
+  const $computed = $([$x, $y], compute);
 
   assert.strictEqual($computed.get(), "TESTwritable");
 
@@ -51,15 +51,15 @@ test("readable, writable, computed: basic functionality", (t) => {
   assert.strictEqual($computed.get(), "TESTcan you hear me now?");
 
   assert.strictEqual(observer.mock.calls.length, 3);
-  assert.deepEqual(observer.mock.calls[0].arguments, ["writable", undefined]);
-  assert.deepEqual(observer.mock.calls[1].arguments, ["new value", "writable"]);
-  assert.deepEqual(observer.mock.calls[2].arguments, ["new value 2", "new value"]);
+  assert.deepEqual(observer.mock.calls[0].arguments, ["writable"]);
+  assert.deepEqual(observer.mock.calls[1].arguments, ["new value"]);
+  assert.deepEqual(observer.mock.calls[2].arguments, ["new value 2"]);
 });
 
 test("writable -> readable -> readable: chained transforms", (t) => {
-  const $$number = writable(5);
-  const $doubled = computed($$number, (x) => x * 2);
-  const $quadrupled = computed($doubled, (x) => x * 2);
+  const $$number = $$(5);
+  const $doubled = $($$number, (x) => x * 2);
+  const $quadrupled = $($doubled, (x) => x * 2);
   const observer = t.mock.fn();
 
   assert.strictEqual($doubled.get(), 10);
@@ -68,12 +68,12 @@ test("writable -> readable -> readable: chained transforms", (t) => {
   const stop = observe($quadrupled, observer);
 
   assert.strictEqual(observer.mock.calls.length, 1);
-  assert.deepEqual(observer.mock.calls[0].arguments, [20, undefined]);
+  assert.deepEqual(observer.mock.calls[0].arguments, [20]);
 
   $$number.set(50);
 
   assert.strictEqual(observer.mock.calls.length, 2);
-  assert.deepEqual(observer.mock.calls[1].arguments, [200, 20]);
+  assert.deepEqual(observer.mock.calls[1].arguments, [200]);
 
   stop();
 
@@ -86,7 +86,7 @@ test("writable -> readable -> readable: chained transforms", (t) => {
 });
 
 test("writable: update", (t) => {
-  const $$numbers = writable(["one", "two", "three"]);
+  const $$numbers = $$(["one", "two", "three"]);
 
   const original = $$numbers.get();
 
@@ -99,54 +99,54 @@ test("writable: update", (t) => {
 });
 
 test("readable, writable, computed: observer called with initial value when registered", (t) => {
-  const $$value = writable(1);
-  const $value = readable(5);
-  const $doubled = computed($value, (x) => x * 2);
-  const $multi = computed([$value, $doubled], ([x, y]) => x + y);
+  const $$value = $$(1);
+  const $value = $(5);
+  const $doubled = $($value, (x) => x * 2);
+  const $multi = $([$value, $doubled], (x, y) => x + y);
 
   // Writable
   const wObserver = t.mock.fn();
   const wStop = observe($$value, wObserver);
   assert.strictEqual(wObserver.mock.calls.length, 1);
-  assert.deepEqual(wObserver.mock.calls[0].arguments, [1, undefined]);
+  assert.deepEqual(wObserver.mock.calls[0].arguments, [1]);
   wStop();
 
   // Readable
   const rObserver = t.mock.fn();
   const rStop = observe($value, rObserver);
   assert.strictEqual(rObserver.mock.calls.length, 1);
-  assert.deepEqual(rObserver.mock.calls[0].arguments, [5, undefined]);
+  assert.deepEqual(rObserver.mock.calls[0].arguments, [5]);
   rStop();
 
   // Computed (single source)
   const cObserver1 = t.mock.fn();
   const cStop1 = observe($doubled, cObserver1);
   assert.strictEqual(cObserver1.mock.calls.length, 1);
-  assert.deepEqual(cObserver1.mock.calls[0].arguments, [10, undefined]);
+  assert.deepEqual(cObserver1.mock.calls[0].arguments, [10]);
   cStop1();
 
   // Computed (multi source)
   const cObserver2 = t.mock.fn();
   const cStop2 = observe($multi, cObserver2);
   assert.strictEqual(cObserver2.mock.calls.length, 1);
-  assert.deepEqual(cObserver2.mock.calls[0].arguments, [15, undefined]);
+  assert.deepEqual(cObserver2.mock.calls[0].arguments, [15]);
   cStop2();
 });
 
 test("computed: basic functionality", (t) => {
-  const $$one = writable(2);
-  const $$two = writable(4);
-  const $$three = writable(8);
+  const $$one = $$(2);
+  const $$two = $$(4);
+  const $$three = $$(8);
 
-  const joinFirst = t.mock.fn(([one, two]) => {
+  const joinFirst = t.mock.fn((one, two) => {
     return one + two;
   });
-  const $first = computed([$$one, $$two], joinFirst);
+  const $first = $([$$one, $$two], joinFirst);
 
-  const joinSecond = t.mock.fn(([one, two, three]) => {
+  const joinSecond = t.mock.fn((one, two, three) => {
     return one + two + three;
   });
-  const $second = computed([$$one, $$two, $$three], joinSecond);
+  const $second = $([$$one, $$two, $$three], joinSecond);
 
   assert.strictEqual($first.get(), 6);
   assert.strictEqual($second.get(), 14);
@@ -158,7 +158,7 @@ test("computed: basic functionality", (t) => {
   const stop = observe($second, observer);
 
   assert.strictEqual(observer.mock.callCount(), 1);
-  assert.deepEqual(observer.mock.calls[0].arguments, [14, undefined]); // Observer receives initial value.
+  assert.deepEqual(observer.mock.calls[0].arguments, [14]); // Observer receives initial value.
   assert.strictEqual(joinSecond.mock.callCount(), 2);
 
   $$two.set(16);
@@ -173,7 +173,7 @@ test("computed: basic functionality", (t) => {
   assert.strictEqual(joinSecond.mock.callCount(), 3);
 
   assert.strictEqual(observer.mock.callCount(), 2); // Observer received value.
-  assert.deepEqual(observer.mock.calls[1].arguments, [26, 14]);
+  assert.deepEqual(observer.mock.calls[1].arguments, [26]);
 
   stop();
 
@@ -189,10 +189,10 @@ test("computed: basic functionality", (t) => {
 });
 
 test("computed: observers received value when undefined", (t) => {
-  const $$one = writable(true);
-  const $$two = writable(false);
+  const $$one = $$(true);
+  const $$two = $$(false);
 
-  const $joined = computed([$$one, $$two], ([one, two]) => {
+  const $joined = $([$$one, $$two], (one, two) => {
     if (one && two) {
       return true;
     }
@@ -207,19 +207,19 @@ test("computed: observers received value when undefined", (t) => {
   const stop = observe($joined, observer);
 
   assert.strictEqual(observer.mock.calls.length, 1);
-  assert.deepEqual(observer.mock.calls[0].arguments, [undefined, undefined]);
+  assert.deepEqual(observer.mock.calls[0].arguments, [undefined]);
 
   $$two.set(true);
 
   assert.strictEqual($joined.get(), true);
   assert.strictEqual(observer.mock.calls.length, 2);
-  assert.deepEqual(observer.mock.calls[1].arguments, [true, undefined]);
+  assert.deepEqual(observer.mock.calls[1].arguments, [true]);
 
   $$one.set(false);
 
   assert.strictEqual($joined.get(), undefined);
   assert.strictEqual(observer.mock.calls.length, 3);
-  assert.deepEqual(observer.mock.calls[2].arguments, [undefined, true]);
+  assert.deepEqual(observer.mock.calls[2].arguments, [undefined]);
 
   stop();
 
@@ -231,14 +231,14 @@ test("computed: observers received value when undefined", (t) => {
 });
 
 test("computed: observer only gets new values when they are different", (t) => {
-  const $$source = writable({ name: "Jimbo Jones", age: 346 });
-  const $age = computed($$source, (x) => x.age);
+  const $$source = $$({ name: "Jimbo Jones", age: 346 });
+  const $age = $($$source, (x) => x.age);
 
   const ageObserver = t.mock.fn();
   const stop = observe($age, ageObserver);
 
   assert.strictEqual(ageObserver.mock.calls.length, 1);
-  assert.deepEqual(ageObserver.mock.calls[0].arguments, [346, undefined]);
+  assert.deepEqual(ageObserver.mock.calls[0].arguments, [346]);
 
   $$source.update((current) => {
     return { ...current, name: "Not Jimbo Jones" };
@@ -251,19 +251,19 @@ test("computed: observer only gets new values when they are different", (t) => {
   });
 
   assert.strictEqual(ageObserver.mock.calls.length, 2); // Age change should have been observed.
-  assert.deepEqual(ageObserver.mock.calls[1].arguments, [347, 346]);
+  assert.deepEqual(ageObserver.mock.calls[1].arguments, [347]);
 
   stop();
 });
 
 test("proxy", (t) => {
-  const $$numbers = writable([1, 2, 3]);
-  const $$hasTwo = proxy($$numbers, {
-    get(source) {
-      return source.get().includes(2);
+  const $$numbers = $$([1, 2, 3]);
+  const $$hasTwo = $$($$numbers, {
+    get() {
+      return $$numbers.get().includes(2);
     },
-    set(source, value) {
-      source.update((numbers) => {
+    set(value) {
+      $$numbers.update((numbers) => {
         if (value && !numbers.includes(2)) {
           return [...numbers, 2].sort();
         }