opshot 0.5.0 → 0.5.2

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

@@ -257,9 +257,83 @@ function evict(handle, node) {
   cascade(handle, rawNode, membership.keys);
 }
 
+// src/utils/predicates.ts
+var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+
+// src/identity.ts
+var readProxyTargets = /* @__PURE__ */ new WeakMap();
+var identityRecords = /* @__PURE__ */ new WeakMap();
+var nextInternId = 0;
+var registerReadProxyTarget = (readProxy, target) => {
+  readProxyTargets.set(readProxy, target);
+};
+var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
+function resolveIdentity(value) {
+  let current = value;
+  while (isObjectLike(current)) {
+    const readTarget = getRegisteredReadProxyTarget(current);
+    if (readTarget !== void 0 && readTarget !== current) {
+      current = readTarget;
+      continue;
+    }
+    const raw = rawOf(current);
+    if (raw !== current) {
+      current = raw;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+var recordFor = (key) => {
+  let record = identityRecords.get(key);
+  if (record === void 0) {
+    record = {};
+    identityRecords.set(key, record);
+  }
+  return record;
+};
+function identify(value) {
+  const target = resolveIdentity(value);
+  if (!isObjectLike(target)) return value;
+  const record = recordFor(target);
+  if (record.token !== void 0) return record.token;
+  const token = Object.freeze({});
+  record.token = token;
+  return token;
+}
+var internIdentity = (key) => {
+  const resolved = resolveIdentity(key);
+  const record = recordFor(resolved);
+  if (record.id !== void 0) return record.id;
+  const id = nextInternId;
+  nextInternId += 1;
+  record.id = id;
+  return id;
+};
+function isSameIdentity(first, second) {
+  const resolvedFirst = resolveIdentity(first);
+  const resolvedSecond = resolveIdentity(second);
+  return resolvedFirst === resolvedSecond;
+}
+
+// src/peelReadProxy.ts
+function peelReadProxy(value) {
+  if (!isObjectLike(value)) return value;
+  let current = value;
+  while (isObjectLike(current)) {
+    const registeredTarget = getRegisteredReadProxyTarget(current);
+    if (registeredTarget === void 0) break;
+    current = registeredTarget;
+  }
+  return current;
+}
+
 // src/handle.ts
 function handleOf(state) {
-  const raw = rawOf(state);
+  const peeled = peelReadProxy(state);
+  if (!isObjectLike(peeled)) return void 0;
+  const raw = rawOf(peeled);
   const record = recordOf(raw);
   if (record === void 0) return void 0;
   for (const handle of record.memberships.keys()) {
@@ -289,6 +363,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 +380,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 +422,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 +451,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,15 +465,10 @@ 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();
 }
 
-// src/utils/predicates.ts
-var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-
 // src/proxy.ts
 var prototypeFunctionOf = (target, key) => {
   for (let holder = Reflect.getPrototypeOf(target); holder !== null; holder = Reflect.getPrototypeOf(holder)) {
@@ -587,7 +662,7 @@ var handler = {
 // src/createMutableState.ts
 installProxyHandler(handler);
 function createMutableState(properties, options) {
-  const incoming = properties;
+  const incoming = peelReadProxy(properties);
   if (typeof incoming !== "object" || incoming === null) return properties;
   if (isIgnored(incoming)) return properties;
   if (Object.isFrozen(incoming)) return properties;
@@ -601,83 +676,13 @@ 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);
   return proxy;
 }
 
-// src/identity.ts
-var readProxyTargets = /* @__PURE__ */ new WeakMap();
-var identityRecords = /* @__PURE__ */ new WeakMap();
-var nextInternId = 0;
-var registerReadProxyTarget = (readProxy, target) => {
-  readProxyTargets.set(readProxy, target);
-};
-var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
-function resolveIdentity(value) {
-  let current = value;
-  while (isObjectLike(current)) {
-    const readTarget = getRegisteredReadProxyTarget(current);
-    if (readTarget !== void 0 && readTarget !== current) {
-      current = readTarget;
-      continue;
-    }
-    const raw = rawOf(current);
-    if (raw !== current) {
-      current = raw;
-      continue;
-    }
-    break;
-  }
-  return current;
-}
-var recordFor = (key) => {
-  let record = identityRecords.get(key);
-  if (record === void 0) {
-    record = {};
-    identityRecords.set(key, record);
-  }
-  return record;
-};
-function identify(value) {
-  const target = resolveIdentity(value);
-  if (!isObjectLike(target)) return value;
-  const record = recordFor(target);
-  if (record.token !== void 0) return record.token;
-  const token = Object.freeze({});
-  record.token = token;
-  return token;
-}
-var internIdentity = (key) => {
-  const resolved = resolveIdentity(key);
-  const record = recordFor(resolved);
-  if (record.id !== void 0) return record.id;
-  const id = nextInternId;
-  nextInternId += 1;
-  record.id = id;
-  return id;
-};
-function isSameIdentity(first, second) {
-  const resolvedFirst = resolveIdentity(first);
-  const resolvedSecond = resolveIdentity(second);
-  return resolvedFirst === resolvedSecond;
-}
-
-// src/peelReadProxy.ts
-function peelReadProxy(value) {
-  if (!isObjectLike(value)) return value;
-  let current = value;
-  while (isObjectLike(current)) {
-    const registeredTarget = getRegisteredReadProxyTarget(current);
-    if (registeredTarget === void 0) break;
-    current = registeredTarget;
-  }
-  return current;
-}
-
 // src/isState.ts
 function isState(value) {
   const resolved = peelReadProxy(value);
@@ -1172,6 +1177,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 +1688,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.2",
 	"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": {