@manyducks.co/dolla 0.69.1 → 0.69.3

package/lib/state.d.ts

@@ -4,11 +4,12 @@ declare const OBSERVE: unique symbol;
  */
 export type StopFunction = () => void;
 type ObserveMethod<T> = (callback: (currentValue: T) => void) => StopFunction;
+type Value<T> = T extends Readable<infer V> ? V : T;
 /**
  * Extracts value types from an array of Readables.
  */
-export type ReadableValues<T extends Readable<any>[]> = {
-    [K in keyof T]: T[K] extends Readable<infer U> ? U : never;
+export type ReadableValues<T extends MaybeReadable<any>[]> = {
+    [K in keyof T]: Value<T[K]>;
 };
 export interface Observable<T> {
     /**
@@ -34,7 +35,6 @@ export interface Writable<T> extends Readable<T> {
     update(callback: (currentValue: T) => T): void;
 }
 export type MaybeReadable<T> = Readable<T> | T;
-type Value<T> = T extends Readable<infer V> ? V : T;
 export declare function isReadable<T>(value: any): value is Readable<T>;
 export declare function isWritable<T>(value: any): value is Writable<T>;
 export declare function $$<T>(value: Writable<T>): Writable<T>;

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.1",
+  "version": "0.69.3",
   "description": "Front-end components, routing and state management.",
   "main": "lib/index.js",
   "types": "./index.d.ts",

package/notes/state.md

@@ -1,71 +0,0 @@
-# State
-
-I want to update the state API to be a single constructor object, similar to built-ins like `Math` and `Array`. The current API has a lot of separate functions that work together in various ways, but I feel it would be easier to explain and understand if these functions were under one namespace.
-
-Current API:
-
-```ts
-import { readable, writable, computed, unwrap, proxy, type Readable, type Writable } from "@manyducks.co/dolla";
-
-const $$writable = writable({ someValue: 5, otherValue: "test" });
-const $readable = readable($$writable);
-const $computed = computed($$writable, (value) => value.someValue * 256);
-const unwrapped = unwrap($computed);
-const $$proxy = proxy($$writable, {
-  get(source) {
-    return source.get().someValue;
-  },
-  set(source, value) {
-    source.update((current) => {
-      return { ...current, someValue: value };
-    });
-  },
-});
-const $multiComputed = computed([$one, $$two, $three], ([one, two, three], [oldOne, oldTwo, oldThree]) => {
-  return one + two + three;
-});
-
-$$writable.get();
-$$writable.set({ someValue: 12, otherValue: null });
-$$writable.update((current) => ({ ...current, someValue: 100 }));
-
-$readable.get();
-```
-
-The main problem with the above is that we have two things (readable and writable) and a bunch of disconnected utility functions.
-
-Proposed API:
-
-```ts
-import { State, type Readable, type Writable } from "@manyducks.co/dolla";
-
-const $$writable = State.writable({ someValue: 5, otherValue: "test" }); // Longhand
-const $$writable = State({ someValue: 5, otherValue: "test" }); // Shorthand
-const $readable = State.readable($$writable);
-const $readable = $$writable.readable(); // Directly from a writable
-const $computed = State.from($$writable, (value) => value.someValue * 256);
-const unwrapped = State.unwrap($computed);
-const $$proxy = State.proxy($$writable, {
-  get(current) {
-    return current.someValue;
-  },
-  set(value, update) {
-    update((current) => {
-      return { ...current, someValue: value };
-    });
-  },
-});
-const $multiComputed = State.from($one, $$two, $three, (one, two, three, ctx) => {
-  // ctx.lastValues = [oldOne, oldTwo, oldThree];
-  // ctx.lastReturned = oldOne + oldTwo + oldThree
-  return one + two + three;
-});
-
-$$writable.get();
-$$writable.set({ someValue: 12, otherValue: null });
-$$writable.update((current) => ({ ...current, someValue: 100 }));
-
-$readable.get();
-```
-
-Now we have one state primitive (`State`), all instances of which implement `Readable` and some of which implement `Writable`. All utility functions are under the same namespace. This also avoids conflicts with Node streams' Readable and Writable which can be an issue with automatic imports.