@ng-org/alien-deepsignals 0.1.2-alpha.5 → 0.1.2-alpha.7

package/README.md

@@ -4,21 +4,23 @@ Deep structural reactivity for plain objects / arrays / Sets built on top of `al
 
 Hooks for Svelte, Vue, and React.
 
-Core idea: wrap a data tree in a `Proxy` that lazily creates per-property signals the first time you read them. Deep mutations emit compact batched patch objects (in a JSON-patch inspired style) that you can track with `watch()`.
+Core idea: wrap a data tree in a `Proxy` that lazily creates per-property signals the first time you read them. Deep mutations emit batched patch objects (in a JSON-patch inspired style) that you can track with `watch()`.
 
 ## Features
 
 - Lazy: signals & child proxies created only when touched.
 - Deep: nested objects, arrays, Sets proxied.
-- Per-property signals: fine‑grained invalidation without traversal on each change.
 - Patch stream: microtask‑batched granular mutations (paths + op) for syncing external stores / framework adapters.
 - Getter => computed: property getters become derived (readonly) signals automatically.
-- `$` accessors: TypeScript exposes `$prop` for each non‑function key plus `$` / `$length` for arrays.
-- Sets: structural `add/delete/clear` emit patches; object entries get synthetic stable ids.
-- Configurable synthetic IDs: custom property generator - the synthetic id is used in the paths of patches to identify objects in sets.
+- Sets: `add/delete/clear/...` methods emit patches; object entries get synthetic stable ids.
+- Configurable synthetic IDs: custom property generator - the synthetic ID is used in the paths of patches to identify objects in sets. By default attached as `@id` property.
 - Read-only properties: protect specific properties from modification.
 - Shallow escape hatch: wrap sub-objects with `shallow(obj)` to track only reference replacement.
 
+## Reference documentation
+
+[Reference documentation is available here on docs.nextgraph.org](https://docs.nextgraph.org/en/reference/alien-deepsignals/).
+
 ## Install
 
 ```bash
@@ -47,417 +49,96 @@ state.settings.add("beta");
 
 ## Frontend Hooks
 
-We provide hooks for Svelte, Vue, and React so that you can use deepSignal objects in your frontend framework. Modifying the object within those components works as usual, just that the component will rerender automatically if the object changed (by an event in the component or a modification from elsewhere).
+We provide hooks for Svelte 3/4, Svelte 5, Vue, and React so that you can use deepSignal objects in your frontend framework. Modifying the object within those components works as usual, just that the component will rerender automatically when the object changed (by a modification in the component or a modification from elsewhere).
+
+Note that you can pass existing deepSignal objects to useDeepSignal (that you are using elsewhere too, for example as shared state) as well as plain JavaScript objects (which are then wrapped).
+
+You can (and are often advised to) use deepSignals as a shared state (and sub objects thereof) across components.
 
-Note that you can pass existing deepSignal objects (that you are using elsewhere too, for example as shared state) as well as plain JavaScript objects (which are then wrapped).
+### React
 
 ```tsx
 import { useDeepSignal } from "@ng-org/alien-deepsignals/react";
+import { DeepSignal } from "@ng-org/alien-deepsignals";
+import UserComponent from "./User.tsx";
+import type { User } from "./types.ts";
+
+function UserManager() {
+    const users: DeepSignal<User[]> = useDeepSignal([{ username: "Bob" }]);
 
-const users = useDeepSignal([{username: "Bob"}]);
-// Note: Instead of calling `setState`, you just need to modify a property. That will trigger the required re-render.
+    return users.map((user) => <UserComponent key={user.id} user={user} />);
+}
+```
+
+In child component `User.tsx`:
+
+```tsx
+function UserComponent({ user }: { user: DeepSignal<User> }) {
+    // Modifications here will trigger a re-render in the parent component
+    // which updates this component.
+    // For performance reasons, you are advised to call `useDeepSignal`
+    // close to where its return value is used.
+    return <input type="text" value={user.name} />;
+}
 ```
 
 ### Vue
 
 In component `UserManager.vue`
+
 ```vue
-<script setup lang="ts"> 
-import { DeepSignal } from "@ng-org/alien-deepsignals";
+<script setup lang="ts">
 import { useDeepSignal } from "@ng-org/alien-deepsignals/vue";
+import { DeepSignal } from "@ng-org/alien-deepsignals";
 import UserComponent from "./User.vue";
-import { User } from "./types.ts";
+import type { User } from "./types.ts";
 
-const users: DeepSignal<User> = useDeepSignal([{username: "Bob", id: 1}]);
+const users: DeepSignal<User[]> = useDeepSignal([{ username: "Bob", id: 1 }]);
 </script>
 
 <template>
-    <UserComponent
-        v-for="user in users"
-        :key="user.id"
-        :user="user"
-    />
+    <UserComponent v-for="user in users" :key="user.id" :user="user" />
 </template>
 ```
+
 In a child component, `User.vue`
+
 ```vue
 <script setup lang="ts">
-import { useDeepSignal } from "@ng-org/alien-deepsignals/vue";
-
 const props = defineProps<{
     user: DeepSignal<User>;
 }>();
 
-// Important!
-// In vue child components, you need to wrap deepSignal objects into useDeepSignal hooks, to ensure the component re-renders.
-const user = useDeepSignal(props.user);
+// The component only rerenders when user.name changes.
+// It behaves the same as an object wrapped with `reactive()`
+const user = props.user;
 </script>
 <template>
-    {{user.name}}
+    <input type="text" v-model:value="user.name" />
 </template>
 ```
 
-### Svelte
-
-```ts
-import { useDeepSignal } from "@ng-org/alien-deepsignals/svelte";
-
-// `users` is a rune of type `{username: string}[]`
-const users = useDeepSignal([{username: "Bob"}]);
-```
-
-## Configuration options
-
-`deepSignal(obj, options?)` accepts an optional configuration object:
-
-```ts
-type DeepSignalOptions = {
-    propGenerator?: (props: {
-        path: (string | number)[];
-        inSet: boolean;
-        object: any;
-    }) => {
-        syntheticId?: string;
-        extraProps?: Record<string, unknown>;
-    };
-    syntheticIdPropertyName?: string;
-    readOnlyProps?: string[];
-};
-```
-
-### Property generator function
-
-The `propGenerator` function is called when a new object is added to the deep signal tree. It receives:
-
-- `path`: The path of the newly added object
-- `inSet`: Whether the object is being added to a Set (true) or not (false)
-- `object`: The newly added object itself
-
-It can return:
-
-- `syntheticId`: A custom identifier for the object (used in Set entry paths and optionally as a property)
-- `extraProps`: Additional properties to be added to the object (overwriting existing ones).
-
-```ts
-let counter = 0;
-const state = deepSignal(
-    { items: new Set() },
-    {
-        propGenerator: ({ path, inSet, object }) => ({
-            syntheticId: inSet
-                ? `urn:item:${++counter}`
-                : `urn:obj:${path.join("-")}`,
-            extraProps: { createdAt: new Date().toISOString() },
-        }),
-        syntheticIdPropertyName: "@id",
-    }
-);
-
-state.items.add({ name: "Item 1" }); // Gets @id: "urn:item:1" and createdAt property
-state.items.add({ name: "Item 2" }); // Gets @id: "urn:item:2"
-```
-
-### Synthetic ID property name
-
-When `syntheticIdPropertyName` is set (e.g., to `"@id"`), objects receive a readonly, enumerable property with the generated synthetic ID:
-
-```ts
-const state = deepSignal(
-    { data: {} },
-    {
-        propGenerator: ({ path, inSet, object }) => ({
-            syntheticId: `urn:uuid:${crypto.randomUUID()}`,
-        }),
-        syntheticIdPropertyName: "@id",
-    }
-);
-
-state.data.user = { name: "Ada" };
-console.log(state.data.user["@id"]); // e.g., "urn:uuid:550e8400-e29b-41d4-a716-446655440000"
-```
-
-### Read-only properties
-
-The `readOnlyProps` option lets you specify property names that cannot be modified:
-
-```ts
-const state = deepSignal(
-    { data: {} },
-    {
-        propGenerator: ({ path, inSet, object }) => ({
-            syntheticId: `urn:uuid:${crypto.randomUUID()}`,
-        }),
-        syntheticIdPropertyName: "@id",
-        readOnlyProps: ["@id", "@graph"],
-    }
-);
-
-state.data.user = { name: "Ada" };
-state.data.user["@id"] = "new-id"; // TypeError: Cannot modify readonly property '@id'
-```
-
-**Key behaviors:**
-
-- Synthetic IDs are assigned **before** the object is proxied, ensuring availability immediately
-- Properties specified in `readOnlyProps` are **readonly** and **enumerable**
-- Synthetic ID assignment emits a patch just like any other property
-- Objects with existing properties matching `syntheticIdPropertyName` keep their values (not overwritten)
-- Options propagate to all nested objects created after initialization
-- The `propGenerator` function is called for both Set entries (`inSet: true`) and regular objects (`inSet: false`)
-
-## Watching patches
-
-`watch(root, cb, options?)` observes a deepSignal root and invokes your callback with microtask‑batched mutation patches plus snapshots.
-
-```ts
-import { watch } from "alien-deepsignals";
-
-const stop = watch(state, ({ patches, oldValue, newValue }) => {
-    for (const p of patches) {
-        console.log(p.op, p.path.join("."), "value" in p ? p.value : p.type);
-    }
-});
-
-state.user.name = "Lin";
-state.items[0].qty = 3;
-await Promise.resolve(); // flush microtask
-stop();
-```
-
-## Computed (derived) values
-
-Use the `computed()` function to create lazy derived signals that automatically track their dependencies and recompute only when needed.
-
-```ts
-import { computed } from "@ng-org/alien-deepsignals";
-
-const state = deepSignal({
-    firstName: "Ada",
-    lastName: "Lovelace",
-    items: [1, 2, 3],
-});
-
-// Create a computed signal that derives from reactive state
-const fullNaAdd documentationme = computed(() => `${state.firstName} ${state.lastName}`);
-const itemCount = computed(() => state.items.length);
-
-console.log(fullName()); // "Ada Lovelace" - computes on first access
-console.log(itemCount()); // 3
-
-state.firstName = "Grace";
-console.log(fullName()); // "Grace Lovelace" - recomputes automatically
-```
-
-**Key benefits:**
-
-- **Lazy evaluation**: The computation runs only when you actually read the computed value. If you never access `fullName()`, the concatenation never happens—no wasted CPU cycles.
-- **Automatic caching**: Once computed, the result is cached until a dependency changes. Multiple reads return the cached value without re-running the getter.
-- **Fine-grained reactivity**: Only recomputes when its tracked dependencies change. Unrelated state mutations don't trigger unnecessary recalculation.
-- **Composable**: Computed signals can depend on other computed signals, forming efficient dependency chains.
-
-```ts
-// Expensive computation only runs when accessed and dependencies change
-const expensiveResult = computed(() => {
-    console.log("Computing...");
-    return state.items.reduce((sum, n) => sum + n * n, 0);
-});
-
-// No computation happens yet!
-state.items.push(4);
-// Still no computation...
-
-console.log(expensiveResult()); // "Computing..." + result
-console.log(expensiveResult()); // Cached, no log
-state.items.push(5);
-console.log(expensiveResult()); // "Computing..." again (dependency changed)
-```
-
-### Callback event shape
-
-```ts
-type WatchPatchEvent<T> = {
-    patches: DeepPatch[]; // empty only on immediate
-    oldValue: T | undefined; // deep-cloned snapshot before batch
-    newValue: T; // live proxy (already mutated)
-    registerCleanup(fn): void; // register disposer for next batch/stop
-    stopListening(): void; // unsubscribe
-};
-```
-
-### Options
-
-| Option      | Type    | Default | Description                                        |
-| ----------- | ------- | ------- | -------------------------------------------------- |
-| `immediate` | boolean | false   | Fire once right away with `patches: []`.           |
-| `once`      | boolean | false   | Auto stop after first callback (immediate counts). |
-
-`observe()` is an alias of `watch()`.
-
-## DeepPatch format
-
-```ts
-type DeepPatch = {
-    root: symbol; // stable id per deepSignal root
-    path: (string | number)[]; // root-relative segments
-} & (
-    | { op: "add"; type: "object" } // assigned object/array/Set entry object
-    | { op: "add"; value: string | number | boolean } // primitive write
-    | { op: "remove" } // deletion
-    | { op: "add"; type: "set"; value: [] } // Set.clear()
-    | {
-          op: "add";
-          type: "set";
-          value: (string | number | boolean)[] | { [id: string]: object };
-      } // (reserved)
-);
-```
-
-Notes:
-
-- `type:'object'` omits value to avoid deep cloning; read from `newValue` if needed.
-- `Set.add(entry)` emits object vs primitive form depending on entry type; path ends with synthetic id.
-- `Set.clear()` emits one structural patch and suppresses per‑entry removals in same batch.
-
-## Sets & synthetic ids
-
-Object entries inside Sets need a stable key for patch paths. The synthetic ID resolution follows this priority:
-
-1. Explicit custom ID via `setSetEntrySyntheticId(entry, 'myId')` (before `add`)
-2. Custom ID property specified by `syntheticIdPropertyName` option (e.g., `entry['@id']`)
-3. Auto-generated blank node ID (`_bN` format)
-
-### Working with Sets
+### Svelte 3 / 4
 
 ```ts
-import { addWithId, setSetEntrySyntheticId } from "@ng-org/alien-deepsignals";
-
-// Option 1: Use automatic ID generation via propGenerator
-const state = deepSignal(
-    { items: new Set() },
-    {
-        propGenerator: ({ path, inSet, object }) => ({
-            syntheticId: inSet ? `urn:uuid:${crypto.randomUUID()}` : undefined,
-        }),
-        syntheticIdPropertyName: "@id",
-    }
-);
-const item = { name: "Item 1" };
-state.items.add(item); // Automatically gets @id before being added
-console.log(item["@id"]); // e.g., "urn:uuid:550e8400-..."
-
-// Option 2: Manually set synthetic ID
-const obj = { value: 42 };
-setSetEntrySyntheticId(obj, "urn:custom:my-id");
-state.items.add(obj);
-
-// Option 3: Use convenience helper
-addWithId(state.items as any, { value: 99 }, "urn:item:special");
-
-// Option 4: Pre-assign property matching syntheticIdPropertyName
-const preTagged = { "@id": "urn:explicit:123", data: "..." };
-state.items.add(preTagged); // Uses "urn:explicit:123" as synthetic ID
-```
-
-### Set entry patches and paths
+import { useDeepSignal } from "@ng-org/alien-deepsignals/svelte4";
 
-When objects are added to Sets, their **synthetic ID becomes part of the patch path**. This allows patches to uniquely identify which Set entry is being mutated.
-
-```ts
-const state = deepSignal(
-    { s: new Set() },
-    {
-        propGenerator: ({ inSet }) => ({
-            syntheticId: inSet ? "urn:entry:set-entry-1" : undefined,
-        }),
-        syntheticIdPropertyName: "@id",
-    }
-);
-
-watch(state, ({ patches }) => {
-    console.log(JSON.stringify(patches));
-    // [
-    //   {"path":["s","urn:entry:set-entry-1"],"op":"add","type":"object"},
-    //   {"path":["s","urn:entry:set-entry-1","@id"],"op":"add","value":"urn:entry:set-entry-1"},
-    //   {"path":["s","urn:entry:set-entry-1","data"],"op":"add","value":"test"}
-    // ]
-});
-
-state.s.add({ data: "test" });
+// `users` is a store of type `{username: string}[]`
+const users = useDeepSignal([{ username: "Bob" }]);
 ```
 
-**Path structure explained:**
-
-- `["s", "urn:entry:set-entry-1"]` - The structural Set patch; the IRI identifies the entry
-- `["s", "urn:entry:set-entry-1", "@id"]` - Patch for the @id property assignment
-- `["s", "urn:entry:set-entry-1", "data"]` - Nested property patch; the IRI identifies which Set entry
-- The synthetic ID (the IRI) is stable across mutations, allowing tracking of the same object
-
-**Mutating nested properties:**
+### Svelte 5
 
 ```ts
-const state = deepSignal(
-    { users: new Set() },
-    {
-        propGenerator: ({ path, inSet }) => ({
-            syntheticId: inSet ? `urn:user:${crypto.randomUUID()}` : undefined,
-        }),
-        syntheticIdPropertyName: "@id",
-    }
-);
-const user = { name: "Ada", age: 30 };
-state.users.add(user); // Gets @id, e.g., "urn:user:550e8400-..."
-
-watch(state, ({ patches }) => {
-    console.log(JSON.stringify(patches));
-    // [{"path":["users","urn:user:550e8400-...","age"],"op":"add","value":31}]
-});
-
-// Later mutation: synthetic ID identifies which Set entry changed
-user.age = 31;
-```
-
-The path `["users", "urn:user:550e8400-...", "age"]` shows:
-
-1. `users` - the Set container
-2. `urn:user:550e8400-...` - the IRI identifying which object in the Set
-3. `age` - the property being mutated
-
-This structure enables precise tracking of nested changes within Set entries, critical for syncing state changes or implementing undo/redo.
-
-## Shallow
-
-Skip deep proxying of a subtree (only reference replacement tracked):
+import { useDeepSignal } from "@ng-org/alien-deepsignals/svelte";
 
-```ts
-import { shallow } from "alien-deepsignals";
-state.config = shallow({ huge: { blob: true } });
+// `users` is a rune of type `{username: string}[]`
+const users = useDeepSignal([{ username: "Bob" }]);
 ```
 
-## TypeScript ergonomics
-
-`DeepSignal<T>` exposes both plain properties and optional `$prop` signal accessors (excluded for function members). Arrays add `$` (index signal map) and `$length`.
-
-```ts
-const state = deepSignal({ count: 0, user: { name: "A" } });
-state.count++; // ok
-state.$count!.set(9); // write via signal
-const n: number = state.$count!(); // typed number
-```
+### Other Frameworks
 
-## API surface
-
-| Function                           | Description                                                        |
-| ---------------------------------- | ------------------------------------------------------------------ |
-| `deepSignal(obj, options?)`        | Create (or reuse) reactive deep proxy with optional configuration. |
-| `watch(root, cb, opts?)`           | Observe batched deep mutations.                                    |
-| `observe(root, cb, opts?)`         | Alias of `watch`.                                                  |
-| `peek(obj,key)`                    | Untracked property read.                                           |
-| `shallow(obj)`                     | Mark object to skip deep proxying.                                 |
-| `isDeepSignal(val)`                | Runtime predicate.                                                 |
-| `isShallow(val)`                   | Was value marked shallow.                                          |
-| `setSetEntrySyntheticId(obj,id)`   | Assign custom Set entry id (highest priority).                     |
-| `addWithId(set, entry, id)`        | Insert with desired synthetic id (convenience).                    |
-| `subscribeDeepMutations(root, cb)` | Low-level patch stream (used by watch).                            |
+Integrating new frontend frameworks is fairly easy. Get in touch if you are interested.
 
 ## License
 

package/dist/core.d.ts

@@ -1,75 +1,81 @@
-/** Lightweight facade adding ergonomic helpers (.value/.peek/.get/.set) to native alien-signals function signals. */
-export { signal as _rawSignal, computed as _rawComputed, startBatch as _rawStartBatch, endBatch as _rawEndBatch, getCurrentSub as _rawGetCurrentSub, setCurrentSub as _rawSetCurrentSub, effect as _rawEffect, } from "alien-signals";
-import { signal as alienSignal, computed as alienComputed } from "alien-signals";
-/** Internal shape of a tagged writable signal after adding ergonomic helpers. */
-type TaggedSignal<T> = ReturnType<typeof alienSignal<T>> & {
-    /** Tracking read / write via property syntax */
-    value: T;
-    /** Non-tracking read */
-    peek(): T;
-    /** Alias for tracking read */
-    get(): T;
-    /** Write helper */
-    set(v: T): void;
-};
+import { computed as alienComputed, signal as alienSignal_, effect as alienEffect } from "alien-signals";
 /**
- * Create a new writable function-form signal enhanced with `.value`, `.peek()`, `.get()`, `.set()`.
+ * Execute multiple signal writes in a single batched update frame.
+ * All downstream computed/effect re-evaluations are deferred until the function exits.
+ *
+ * IMPORTANT: The callback must be synchronous. If it returns a Promise the batch will
+ * still end immediately after scheduling, possibly causing mid-async flushes.
  *
  * @example
- * const count = signal(0);
- * count();      // 0 (track)
- * count(1);     // write
- * count.value;  // 1 (track)
- * count.peek(); // 1 (non-tracking)
+ * ```ts
+ * batch(() => {
+ *   count(count() + 1);
+ *   other(other() + 2);
+ * }); // effects observing both run only once
+ * ```
  */
-export declare const signal: <T>(v?: T) => TaggedSignal<any>;
-/** Internal shape of a tagged computed signal after adding ergonomic helpers. */
-type TaggedComputed<T> = ReturnType<typeof alienComputed<T>> & {
-    /** Tracking read via property syntax (readonly) */
-    readonly value: T;
-    /** Non-tracking read */
-    peek(): T;
-    /** Alias for tracking read */
-    get(): T;
-};
+export declare function batch<T>(fn: () => T): T;
 /**
- * Create a lazy computed (readonly) signal derived from other signals.
+ * Re-export of alien-signals computed function.
  *
- * Computed signals are automatically cached and only recompute when their tracked
- * dependencies change. The getter function is evaluated lazily—if you never read
- * the computed value, the computation never runs.
+ * Use the `computed()` function to create lazy derived signals that automatically
+ * track their dependencies and recompute only when needed.
  *
- * The returned function can be called directly `computed()` or accessed via `.value`.
- * Use `.peek()` for non-tracking reads (won't establish reactive dependency).
+ * Key features:
+ * - **Lazy evaluation**: The computation runs only when you actually read the computed value.
+ *     If you never access `fullName()`, the concatenation never happens—no wasted CPU cycles.
+ * - **Automatic caching**: Once computed, the result is cached until a dependency changes.
+ *     Multiple reads return the cached value without re-running the getter.
+ * - **Fine-grained reactivity**: Only recomputes when its tracked dependencies change.
+ *     Unrelated state mutations don't trigger unnecessary recalculation.
+ * - **Composable**: Computed signals can depend on other computed signals,
+ *     forming efficient dependency chains.
  *
  * @example
- * const count = signal(5);
- * const doubled = computed(() => count() * 2);
- * doubled();       // 10 (establishes dependency, caches result)
- * doubled.value;   // 10 (cached, same as calling it)
- * doubled.peek();  // 10 (no dependency tracking)
- * count(10);
- * doubled();       // 20 (recomputed because count changed)
+ * ```ts
+ * import { computed } from "@ng-org/alien-deepsignals";
+ *
+ * const state = deepSignal({
+ *     firstName: "Ada",
+ *     lastName: "Lovelace",
+ *     items: [1, 2, 3],
+ * });
+ *
+ * // Create a computed signal that derives from reactive state
+ * const fullName = computed(() => `${state.firstName} ${state.lastName}`);
+ *
+ * console.log(fullName()); // "Ada Lovelace" - computes on first access
+ *
+ * state.firstName = "Grace";
+ * console.log(fullName()); // "Grace Lovelace" - recomputes automatically
+ *
+ * // Expensive computation only runs when accessed and dependencies change
+ * const expensiveResult = computed(() => {
+ *     console.log("Computing...");
+ *     return state.items.reduce((sum, n) => sum + n * n, 0);
+ * });
+ *
+ * // No computation happens yet!
+ * state.items.push(4);
+ * // Still no computation...
+ *
+ * console.log(expensiveResult()); // "Computing..." + result
+ * console.log(expensiveResult()); // Cached, no log
+ * state.items.push(5);
+ * console.log(expensiveResult()); // "Computing..." again (dependency changed)
+ *
+ * ```
  */
-export declare const computed: <T>(getter: () => T) => TaggedComputed<T>;
-/** Union allowing a plain value or a writable signal wrapping that value. */
-export type MaybeSignal<T = any> = T | ReturnType<typeof signal>;
-/** Union allowing value, writable signal, computed signal or plain getter function. */
-export type MaybeSignalOrGetter<T = any> = MaybeSignal<T> | ReturnType<typeof computed> | (() => T);
-/** Runtime guard that an unknown value is one of our tagged signals/computeds. */
-export declare const isSignal: (s: any) => boolean;
+export declare const computed: typeof alienComputed;
 /**
- * Execute multiple signal writes in a single batched update frame.
- * All downstream computed/effect re-evaluations are deferred until the function exits.
+ * Re-export of alien-signals `signal` function which creates a basic signal.
+ */
+export declare const alienSignal: typeof alienSignal_;
+/**
+ * Re-export of alien-signals effect function.
  *
- * IMPORTANT: The callback MUST be synchronous. If it returns a Promise the batch will
- * still end immediately after scheduling, possibly causing mid-async flushes.
+ * Callback reruns on every signal modification that is used within its callback.
  *
- * @example
- * batch(() => {
- *   count(count() + 1);
- *   other(other() + 2);
- * }); // effects observing both run only once
  */
-export declare function batch<T>(fn: () => T): T;
+export declare const effect: typeof alienEffect;
 //# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAUA,qHAAqH;AAGrH,OAAO,EACH,MAAM,IAAI,UAAU,EACpB,QAAQ,IAAI,YAAY,EACxB,UAAU,IAAI,cAAc,EAC5B,QAAQ,IAAI,YAAY,EACxB,aAAa,IAAI,iBAAiB,EAClC,aAAa,IAAI,iBAAiB,EAClC,MAAM,IAAI,UAAU,GACvB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACH,MAAM,IAAI,WAAW,EACrB,QAAQ,IAAI,aAAa,EAI5B,MAAM,eAAe,CAAC;AAKvB,iFAAiF;AACjF,KAAK,YAAY,CAAC,CAAC,IAAI,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG;IACvD,gDAAgD;IAChD,KAAK,EAAE,CAAC,CAAC;IACT,wBAAwB;IACxB,IAAI,IAAI,CAAC,CAAC;IACV,8BAA8B;IAC9B,GAAG,IAAI,CAAC,CAAC;IACT,mBAAmB;IACnB,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;CACnB,CAAC;AA6BF;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,IAAI,CAAC,sBAA8B,CAAC;AAC9D,iFAAiF;AACjF,KAAK,cAAc,CAAC,CAAC,IAAI,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG;IAC3D,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,wBAAwB;IACxB,IAAI,IAAI,CAAC,CAAC;IACV,8BAA8B;IAC9B,GAAG,IAAI,CAAC,CAAC;CACZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,QAAQ,MAAM,CAAC,KAAG,cAAc,CAAC,CAAC,CACxB,CAAC;AAEvC,6EAA6E;AAC7E,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;AACjE,uFAAuF;AACvF,MAAM,MAAM,mBAAmB,CAAC,CAAC,GAAG,GAAG,IACjC,WAAW,CAAC,CAAC,CAAC,GACd,UAAU,CAAC,OAAO,QAAQ,CAAC,GAC3B,CAAC,MAAM,CAAC,CAAC,CAAC;AAChB,kFAAkF;AAClF,eAAO,MAAM,QAAQ,GAAI,GAAG,GAAG,KAAG,OACiC,CAAC;AAEpE;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAOvC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAUA,OAAO,EAGH,QAAQ,IAAI,aAAa,EACzB,MAAM,IAAI,YAAY,EACtB,MAAM,IAAI,WAAW,EACxB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAOvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,QAAQ,sBAAgB,CAAC;AAEtC;;GAEG;AACH,eAAO,MAAM,WAAW,qBAAe,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,MAAM,oBAAc,CAAC"}