opshot 0.5.0 → 0.5.1

package/README.md

@@ -206,6 +206,8 @@ const Chart = () => {
 };
 ```
 
+Separate from that callback, the `flush(state)` export ends the window from outside.
+
 ## Batches
 
 `batch` runs a callback and tags every write inside it with your `meta`, so a listener can tell its own writes from everyone else's.

package/dist/index.d.ts

@@ -250,6 +250,13 @@ declare function subscribe(state: object, listener: StateListener): () => void;
  */
 declare function batch(callback: () => void, meta?: unknown): void;
 
+/**
+ * Ends the state's window now, delivering the operations gathered so far.
+ *
+ * @param state - State to flush.
+ */
+declare function flush(state: object): void;
+
 /**
  * Wraps a component so it re-renders only when fields it read change.
  *
@@ -269,4 +276,4 @@ declare function scope<P extends object>(Component: ComponentType<P>): FC<P>;
  */
 declare function useMutableState<T extends object>(properties: (() => T) | T, options?: MutableStateOptions): T;
 
-export { type EmissionScheduler, type MutableStateOptions, type Operation, type StateListener, TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };
+export { type EmissionScheduler, type MutableStateOptions, type Operation, type StateListener, TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, flush, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };

package/dist/index.js

@@ -289,6 +289,7 @@ function batch(callback, meta) {
 
 // src/emit/emitterDeliver.ts
 var runDelivery = (pending, failures) => {
+  pending.handle.lastDirty = pending.dirty;
   for (const deliver of pending.deliveries) {
     try {
       deliver(pending.operations);
@@ -305,9 +306,11 @@ var raiseFailures = (failures) => {
 var queuedDeliveries = [];
 var deliveryFailures = [];
 var isDraining = false;
-var prepareDelivery = (handle, operations) => ({
+var prepareDelivery = (handle, operations, dirty) => ({
   deliveries: [...handle.subscribers.values()],
-  operations
+  operations,
+  handle,
+  dirty
 });
 var enqueueDelivery = (pending) => {
   queuedDeliveries.push(pending);
@@ -345,19 +348,21 @@ function recordOperation(handle, raw, pending) {
   }
   handle.pending.push(pending);
   byKey.set(pending.key, handle.pending.length - 1);
-  if (handle.isFlushScheduled) return;
-  handle.isFlushScheduled = true;
+  if (handle.scheduledFlush !== void 0) return;
   const run = () => {
-    flush(handle);
+    if (handle.scheduledFlush !== run) return;
+    flushWindow(handle);
   };
+  handle.scheduledFlush = run;
   void Promise.resolve().then(() => {
+    if (handle.scheduledFlush !== run) return;
     const emitOn = handle.emitOn;
     if (emitOn === void 0) run();
     else emitOn(run);
   });
 }
-function flush(handle) {
-  handle.isFlushScheduled = false;
+function flushWindow(handle) {
+  handle.scheduledFlush = void 0;
   const pending = handle.pending.splice(0);
   handle.pendingIndex.clear();
   const operations = new Array();
@@ -372,6 +377,7 @@ function flush(handle) {
     };
     operations.push(Object.freeze(operation));
   }
+  if (operations.length === 0) return;
   const edges = /* @__PURE__ */ new Map();
   const nodes = /* @__PURE__ */ new Set();
   for (const operation of operations) {
@@ -385,9 +391,7 @@ function flush(handle) {
     nodes.add(raw);
   }
   const dirty = { edges, nodes };
-  handle.lastDirty = dirty;
-  if (operations.length === 0) return;
-  enqueueDelivery(prepareDelivery(handle, operations));
+  enqueueDelivery(prepareDelivery(handle, operations, dirty));
   drainDeliveries();
 }
 
@@ -601,8 +605,7 @@ function createMutableState(properties, options) {
     emitOn: options?.emitOn,
     subscribers: /* @__PURE__ */ new Map(),
     pending: [],
-    pendingIndex: /* @__PURE__ */ new Map(),
-    isFlushScheduled: false
+    pendingIndex: /* @__PURE__ */ new Map()
   };
   const proxy = proxyOf(root);
   attachRoot(handle, root, exempt);
@@ -1172,6 +1175,11 @@ function subscribe(state, listener) {
   return addStateListener(state, listener, listener);
 }
 
+// src/flush.ts
+function flush(state) {
+  flushWindow(requireHandle(state, "opshot: flush requires a state"));
+}
+
 // src/react/propWalk.ts
 var stateKeysByContainer = /* @__PURE__ */ new WeakMap();
 var noStateKeys = /* @__PURE__ */ new Set();
@@ -1678,4 +1686,4 @@ function useMutableState(properties, options) {
   return readProxy;
 }
 
-export { TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };
+export { TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, flush, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opshot",
-	"version": "0.5.0",
+	"version": "0.5.1",
 	"description": "Plain-object state for React: mutate it directly, re-render only the components that read what changed, and track every change operation",
 	"type": "module",
 	"exports": {