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

package/src/renderable.ts

@@ -1,5 +1,6 @@
 import { binding, isCompiledBinding } from './compiled/core.ts'
 import type { CompiledBinding, CompiledRenderValue, CompiledScope } from './compiled/types.ts'
+import { compiledComponentSpread } from './component-spread.ts'
 import { Fragment, h, type DirectComponent } from './direct-dom.ts'
 import {
   installRenderableClone,
@@ -48,6 +49,35 @@ export function createRenderable(
   return capability
 }
 
+export function createComponentRenderable(
+  type: DirectComponent,
+  input: RenderablePropsInput,
+  identity: unknown = type,
+): CompiledRenderable {
+  return createRenderable(
+    input,
+    (currentInput) =>
+      h(
+        type,
+        { ...renderableComponentProps(currentInput), ref: renderableRef(currentInput) },
+        renderableChildren(currentInput),
+      ),
+    identity,
+    true,
+  )
+}
+
+function renderableComponentProps(input: RenderablePropsInput): Record<string, unknown> {
+  const ordinary = projectInput<Record<string, unknown>>(input, (props) =>
+    Object.fromEntries(
+      Reflect.ownKeys(props)
+        .filter((name) => typeof name !== 'string' || !SPECIAL_PROPS.has(name))
+        .map((name) => [name, Reflect.get(props, name)]),
+    ),
+  )
+  return isCompiledBinding(ordinary) ? compiledComponentSpread(ordinary, []) : ordinary
+}
+
 export function isRenderable(value: unknown): value is CompiledRenderable {
   return isRenderableProtocol(value)
 }

package/src/source-mask.ts

@@ -50,6 +50,17 @@ export function intersectsSources(left: SourceMask, right: SourceMask): boolean
   return false
 }
 
+export function forEachSource(mask: SourceMask, visit: (index: number) => void): void {
+  if (typeof mask === 'number') {
+    visitWordSources(mask, 0, visit)
+    return
+  }
+
+  for (let word = 0; word < mask.length; word += 1) {
+    visitWordSources(mask[word] ?? 0, word * BITS_PER_WORD, visit)
+  }
+}
+
 export function isEmptySources(mask: SourceMask): boolean {
   if (typeof mask === 'number') return mask === 0
   for (const word of mask) {
@@ -78,6 +89,15 @@ function wordAt(mask: SourceMask, index: number): number {
   return mask[index] ?? 0
 }
 
+function visitWordSources(word: number, offset: number, visit: (index: number) => void): void {
+  let remaining = word >>> 0
+  while (remaining !== 0) {
+    const bit = 31 - Math.clz32(remaining)
+    visit(offset + bit)
+    remaining = (remaining & ~(1 << bit)) >>> 0
+  }
+}
+
 function wordLength(mask: SourceMask): number {
   return typeof mask === 'number' ? 1 : mask.length
 }

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,
   }
 }