opshot 0.5.2 → 0.6.0

package/dist/createMutableState-DJ9dmpR-.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Sets when a state's window flushes. Call `flush` once.
+ *
+ * @param flush - Delivers pending operations.
+ * @returns Nothing.
+ */
+type EmissionScheduler = (flush: () => void) => void;
+/**
+ * Options for `createMutableState`.
+ *
+ * @example
+ * createMutableState({ count: 0 }, { emitOn, strict: false })
+ */
+interface MutableStateOptions {
+    /**
+     * When the window flushes for all writes. Defaults to a microtask.
+     */
+    readonly emitOn?: EmissionScheduler;
+    /**
+     * When true, throws at a dangerous edge, at the cause. Defaults to true.
+     */
+    readonly strict?: boolean;
+}
+/**
+ * Creates a mutable state object.
+ *
+ * `ignore()` marks an object so every edge to it is untracked. `unsafeTrack()` marks an object so a node entering while marked, or entering beneath an exempt node, is exempt from strict.
+ *
+ * @typeParam T - State shape.
+ * @param properties - Initial fields.
+ * @param options - Creation options.
+ * @returns The state.
+ */
+declare function createMutableState<T extends object>(properties: T, options?: MutableStateOptions): T;
+
+export { type EmissionScheduler as E, type MutableStateOptions as M, createMutableState as c };

package/dist/index.d.ts

@@ -1,39 +1,4 @@
-import { ComponentType, FC } from 'react';
-
-/**
- * Sets when a state's window flushes. Call `flush` once.
- *
- * @param flush - Delivers pending operations.
- * @returns Nothing.
- */
-type EmissionScheduler = (flush: () => void) => void;
-/**
- * Options for `createMutableState`.
- *
- * @example
- * createMutableState({ count: 0 }, { emitOn, strict: false })
- */
-interface MutableStateOptions {
-    /**
-     * When the window flushes for all writes. Defaults to a microtask.
-     */
-    readonly emitOn?: EmissionScheduler;
-    /**
-     * When true, throws at a dangerous edge, at the cause. Defaults to true.
-     */
-    readonly strict?: boolean;
-}
-/**
- * Creates a mutable state object.
- *
- * `ignore()` marks an object so every edge to it is untracked. `unsafeTrack()` marks an object so a node entering while marked, or entering beneath an exempt node, is exempt from strict.
- *
- * @typeParam T - State shape.
- * @param properties - Initial fields.
- * @param options - Creation options.
- * @returns The state.
- */
-declare function createMutableState<T extends object>(properties: T, options?: MutableStateOptions): T;
+export { E as EmissionScheduler, M as MutableStateOptions, c as createMutableState } from './createMutableState-DJ9dmpR-.js';
 
 /**
  * Returns a stable identity key for a value.
@@ -59,34 +24,61 @@ declare function isSameIdentity(first: object, second: object): boolean;
  */
 declare function isState(value: unknown): value is object;
 
-/**
- * A change to one key of a node.
- *
- * @example
- * { node, key: "count", before: 0, after: 1, meta: undefined }
- */
-interface Operation {
+interface OperationBase<M> {
     /**
-     * Node that changed.
+     * Node that changed; writes through it are tracked.
      */
-    readonly node: object;
+    readonly node: Record<string, unknown>;
     /**
      * Key that changed.
      */
     readonly key: string;
     /**
-     * Value before, absent when the key was absent.
+     * Meta of the batch the write was made in.
      */
-    readonly before?: unknown;
+    readonly meta: M;
+}
+interface AddOperation<M = unknown> extends OperationBase<M> {
     /**
-     * Value after, absent when the key is absent.
+     * The key was absent before.
      */
-    readonly after?: unknown;
+    readonly kind: "add";
     /**
-     * Meta of the batch the write was made in.
+     * Value after.
      */
-    readonly meta: unknown;
+    readonly after: unknown;
 }
+interface ChangeOperation<M = unknown> extends OperationBase<M> {
+    /**
+     * The key held a value before and after.
+     */
+    readonly kind: "change";
+    /**
+     * Value before.
+     */
+    readonly before: unknown;
+    /**
+     * Value after.
+     */
+    readonly after: unknown;
+}
+interface DeleteOperation<M = unknown> extends OperationBase<M> {
+    /**
+     * The key is absent after.
+     */
+    readonly kind: "delete";
+    /**
+     * Value before.
+     */
+    readonly before: unknown;
+}
+/**
+ * A change to one key of a node.
+ *
+ * @example
+ * { kind: "change", node, key: "count", before: 0, after: 1, meta: undefined }
+ */
+type Operation<M = unknown> = AddOperation<M> | ChangeOperation<M> | DeleteOperation<M>;
 
 /**
  * Marks an object so every edge to it is untracked in every state.
@@ -231,49 +223,33 @@ declare class TrackedSet<T> {
  *
  * @param operations - Operations for the change.
  */
-type StateListener = (operations: ReadonlyArray<Operation>) => void;
+type StateListener<M = unknown> = (operations: ReadonlyArray<Operation<M>>) => void;
 
 /**
  * Listens for changes to a state.
  *
+ * @typeParam M - Meta type the caller asserts for the state's batches.
  * @param state - State to listen to.
  * @param listener - Called on each change.
  * @returns Unsubscribe function.
  */
-declare function subscribe(state: object, listener: StateListener): () => void;
+declare function subscribe<M = unknown>(state: object, listener: StateListener<M>): () => void;
 
 /**
  * Runs writes carrying `meta`.
+ * A callback that returns a promise throws: the meta covers only what runs before its first await.
  *
  * @param callback - Function that writes any states.
  * @param meta - Carried by each write's operation.
  */
-declare function batch(callback: () => void, meta?: unknown): void;
+declare function batch(callback: () => void | undefined, meta?: unknown): void;
 
 /**
- * Ends the state's window now, delivering the operations gathered so far.
+ * Ends each state's window now, delivering the operations gathered so far.
  *
  * @param state - State to flush.
+ * @param states - Further states, flushed in order.
  */
-declare function flush(state: object): void;
-
-/**
- * Wraps a component so it re-renders only when fields it read change.
- *
- * @typeParam P - Props type.
- * @param Component - Component to wrap.
- * @returns The wrapped component.
- */
-declare function scope<P extends object>(Component: ComponentType<P>): FC<P>;
-
-/**
- * Creates mutable state for a component.
- *
- * @typeParam T - State shape.
- * @param properties - Initial fields, or a function that returns them.
- * @param options - Creation options.
- * @returns The state.
- */
-declare function useMutableState<T extends object>(properties: (() => T) | T, options?: MutableStateOptions): T;
+declare function flush(state: object, ...states: ReadonlyArray<object>): void;
 
-export { type EmissionScheduler, type MutableStateOptions, type Operation, type StateListener, TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, flush, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };
+export { type AddOperation, type ChangeOperation, type DeleteOperation, type Operation, type StateListener, TrackedDate, TrackedMap, TrackedSet, batch, flush, identify, ignore, isSameIdentity, isState, subscribe, unsafeTrack };