@vidact/runtime 0.2.0-beta.7 → 0.2.0-beta.8

package/src/state-slot.ts

@@ -24,6 +24,59 @@ export interface StateSlot<T> {
   readonly replace: (value: T) => void
 }
 
+export interface ReadOnlyStateInvalidationTarget {
+  readonly [1]: (sources: SourceMask) => void
+}
+
+export interface ReadOnlyStateCell<T> extends Pick<StateSlot<T>, 'get'> {
+  value: T
+  revision?: number
+  readonly invalidationTarget: ReadOnlyStateInvalidationTarget
+  readonly source: SourceMask
+}
+
+export function createReadOnlyStateSlot<T>(
+  invalidationTarget: ReadOnlyStateInvalidationTarget,
+  source: SourceMask,
+  initialValue: T,
+): ReadOnlyStateCell<T> {
+  return {
+    value: initialValue,
+    invalidationTarget,
+    source,
+    get: readReadOnlyState,
+  }
+}
+
+function readReadOnlyState<T>(this: ReadOnlyStateCell<T>): T {
+  return this.value
+}
+
+export function replaceReadOnlyStateSlot<T>(cell: ReadOnlyStateCell<T>, replacement: T): void {
+  if (Object.is(cell.value, replacement)) return
+  const revision = cell.revision ?? 0
+  if (
+    stateWriteInterceptor?.({
+      slot: cell,
+      revision,
+      update: replacement,
+      commit: (pending) => applyReadOnlyState(cell, pending as T),
+      currentRevision: () => cell.revision ?? 0,
+    })
+  ) {
+    cell.revision ??= revision
+    return
+  }
+  applyReadOnlyState(cell, replacement)
+}
+
+function applyReadOnlyState<T>(cell: ReadOnlyStateCell<T>, next: T): void {
+  if (Object.is(cell.value, next)) return
+  cell.value = next
+  if (cell.revision !== undefined) cell.revision += 1
+  cell.invalidationTarget[1](cell.source)
+}
+
 export function createStateSlot<T>(
   invalidate: (sources: SourceMask) => void,
   source: SourceMask,
@@ -32,45 +85,48 @@ export function createStateSlot<T>(
 ): StateSlot<T> {
   let value = initialValue
   let revision = 0
-  const token = {}
+  let token: object | undefined
 
-  const commit = (next: T): void => {
+  const apply = (next: T): void => {
     if (Object.is(value, next)) return
 
     value = next
     revision += 1
     invalidate(source)
   }
-  const commitUpdate = (update: StateUpdate<T>): void => {
-    const next = typeof update === 'function' ? (update as (previous: T) => T)(value) : update
-    commit(next)
-  }
-  const commitReplacement = (replacement: StateUpdate<T>): void => commit(replacement as T)
-  const write = (update: StateUpdate<T>, commitWrite: (update: StateUpdate<T>) => void): void => {
-    if (
-      stateWriteInterceptor?.({
-        slot: token,
-        revision,
-        update,
-        commit: commitWrite,
-        currentRevision: () => revision,
-      })
-    ) {
-      return
-    }
-    commitWrite(update)
-  }
-  const replace = (next: T): void => {
-    assertWritable?.()
-    write(next, commitReplacement)
-  }
 
   return {
     get: () => value,
     set: (update) => {
       assertWritable?.()
-      write(update, commitUpdate)
+      if (
+        stateWriteInterceptor?.({
+          slot: (token ??= {}),
+          revision,
+          update,
+          commit: (pending) =>
+            apply(typeof pending === 'function' ? (pending as (previous: T) => T)(value) : pending),
+          currentRevision: () => revision,
+        })
+      ) {
+        return
+      }
+      apply(typeof update === 'function' ? (update as (previous: T) => T)(value) : update)
+    },
+    replace: (replacement) => {
+      assertWritable?.()
+      if (
+        stateWriteInterceptor?.({
+          slot: (token ??= {}),
+          revision,
+          update: replacement,
+          commit: (pending) => apply(pending as T),
+          currentRevision: () => revision,
+        })
+      ) {
+        return
+      }
+      apply(replacement)
     },
-    replace,
   }
 }