@vidact/runtime 0.2.0-beta.0 → 0.2.0-beta.10

package/src/shared/promise.ts

@@ -0,0 +1,28 @@
+export function abortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException('The operation was aborted', 'AbortError')
+}
+
+export function isPromiseLike<Value>(value: unknown): value is PromiseLike<Value> {
+  return (
+    ((typeof value === 'object' && value !== null) || typeof value === 'function') &&
+    typeof (value as PromiseLike<Value>).then === 'function'
+  )
+}
+
+export function withAbort<Value>(operation: Promise<Value>, signal: AbortSignal): Promise<Value> {
+  if (signal.aborted) return Promise.reject(abortReason(signal))
+  return new Promise((resolve, reject) => {
+    const onAbort = (): void => reject(abortReason(signal))
+    signal.addEventListener('abort', onAbort, { once: true })
+    void operation.then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort)
+        resolve(value)
+      },
+      (error: unknown) => {
+        signal.removeEventListener('abort', onAbort)
+        reject(error)
+      },
+    )
+  })
+}

package/src/source-mask.ts

@@ -0,0 +1,103 @@
+const BITS_PER_WORD = 32
+const DEV = typeof __VIDACT_DEV__ === 'undefined' || __VIDACT_DEV__
+
+export type SourceMask = number | Uint32Array
+
+export function source(index: number): SourceMask {
+  if (!Number.isSafeInteger(index) || index < 0) {
+    throw new RangeError(
+      DEV ? `source index must be a non-negative safe integer, received ${index}` : 'V701',
+    )
+  }
+
+  const word = Math.floor(index / BITS_PER_WORD)
+  const bit = (1 << (index % BITS_PER_WORD)) >>> 0
+  if (word === 0) return bit
+
+  const words = new Uint32Array(word + 1)
+  words[word] = bit
+  return words
+}
+
+export function combineSources(...masks: readonly SourceMask[]): SourceMask {
+  const length = masks.reduce<number>((maximum, mask) => Math.max(maximum, wordLength(mask)), 1)
+  if (length === 1) {
+    let combined = 0
+    for (const mask of masks) combined = (combined | wordAt(mask, 0)) >>> 0
+    return combined
+  }
+
+  const combined = new Uint32Array(length)
+  for (const mask of masks) {
+    for (let index = 0; index < wordLength(mask); index += 1) {
+      combined[index] = ((combined[index] ?? 0) | wordAt(mask, index)) >>> 0
+    }
+  }
+  return combined
+}
+
+export function intersectsSources(left: SourceMask, right: SourceMask): boolean {
+  if (typeof left === 'number' && typeof right === 'number') {
+    return (left & right) >>> 0 !== 0
+  }
+
+  const leftLength = wordLength(left)
+  const rightLength = wordLength(right)
+  const length = Math.min(leftLength, rightLength)
+  for (let index = 0; index < length; index += 1) {
+    if ((wordAt(left, index) & wordAt(right, index)) >>> 0 !== 0) return true
+  }
+  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) {
+    if (word !== 0) return false
+  }
+  return true
+}
+
+export function unionSources(left: SourceMask, right: SourceMask): SourceMask {
+  if (typeof left === 'number' && typeof right === 'number') {
+    return (left | right) >>> 0
+  }
+
+  const leftLength = wordLength(left)
+  const rightLength = wordLength(right)
+  const length = Math.max(leftLength, rightLength)
+  const words = new Uint32Array(length)
+  for (let index = 0; index < length; index += 1) {
+    words[index] = (wordAt(left, index) | wordAt(right, index)) >>> 0
+  }
+  return words
+}
+
+function wordAt(mask: SourceMask, index: number): number {
+  if (typeof mask === 'number') return index === 0 ? mask : 0
+  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/spread.ts

@@ -0,0 +1,131 @@
+import {
+  binding as createBinding,
+  mountCompiledPropTransition,
+  mountCompiledRef,
+  registerCompiledCleanup,
+} from './compiled/core.ts'
+import type { CompiledBinding } from './compiled/types.ts'
+import { attachEventProp, isEventProp } from './dom/events.ts'
+import { INTERNAL_NAMESPACE_PROP } from './dom/intrinsic.ts'
+import {
+  applyDomProp,
+  ensureControlledFormRestoration,
+  isControlledFormProp,
+} from './dom/properties.ts'
+
+const DEV = typeof __VIDACT_DEV__ === 'undefined' || __VIDACT_DEV__
+let spreadId = 0
+
+export function compiledSpread(
+  binding: CompiledBinding<unknown>,
+  overriddenNames: readonly string[],
+): Record<string, (element: Element) => boolean> {
+  return {
+    [`__vidactSpread${spreadId++}`]: (element) =>
+      mountReactiveSpread(element, binding, overriddenNames),
+  }
+}
+
+function mountReactiveSpread(
+  element: Element,
+  binding: CompiledBinding<unknown>,
+  overriddenNames: readonly string[],
+): boolean {
+  const overrides = new Set(overriddenNames)
+  const cleanups = new Map<string, () => void>()
+  let controlledCleanup: (() => void) | undefined
+  let restoreAfterChildren = false
+  const active = (value: unknown): Record<string, unknown> => {
+    if (value === null || value === undefined) return {}
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      throw new TypeError(DEV ? 'reactive JSX spread value must be an object or nullish' : 'V105')
+    }
+    return value as Record<string, unknown>
+  }
+  if (!overrides.has('ref')) {
+    mountCompiledRef(
+      element,
+      createBinding(binding[2], binding[3], () => active(binding[1]()).ref, binding[4], binding[5]),
+    )
+    overrides.add('ref')
+  }
+  const apply = (name: string, value: unknown): (() => void) => {
+    if (
+      name === 'children' ||
+      name === 'key' ||
+      name === 'dangerouslySetInnerHTML' ||
+      name === INTERNAL_NAMESPACE_PROP
+    ) {
+      throw new TypeError(
+        DEV
+          ? `reactive JSX spread property ${name} requires dedicated ownership semantics`
+          : 'V105',
+      )
+    }
+    if (isControlledFormProp(element, name) && controlledCleanup === undefined) {
+      controlledCleanup = ensureControlledFormRestoration(element)
+    }
+    if (name === 'value' && element instanceof HTMLSelectElement) restoreAfterChildren = true
+    if (isEventProp(name)) return attachEventProp(element, name, value)
+    applyDomProp(element, name, value)
+    return () => {}
+  }
+  const visibleEntries = (value: Record<string, unknown>): Array<[string, unknown]> =>
+    Object.entries(value).filter(([name]) => !overrides.has(name))
+
+  mountCompiledPropTransition(
+    binding,
+    (initial) => {
+      for (const [name, value] of visibleEntries(active(initial))) {
+        cleanups.set(name, apply(name, value))
+      }
+    },
+    (nextValue, previousValue) => {
+      const next = active(nextValue)
+      const previous = active(previousValue)
+      const names = new Set([...Object.keys(previous), ...Object.keys(next)])
+      const changes = [...names]
+        .filter((name) => !overrides.has(name) && !Object.is(next[name], previous[name]))
+        .map((name) => ({ name, next: next[name], previous: previous[name] }))
+      const undo: Array<() => void> = []
+      return [
+        () => {
+          for (const change of changes) {
+            const previousCleanup = cleanups.get(change.name)
+            let nextCleanup: () => void
+            try {
+              nextCleanup = apply(change.name, change.next)
+            } catch (error) {
+              try {
+                apply(change.name, change.previous)
+              } catch {
+                // Preserve the spread property error that aborted publication.
+              }
+              throw error
+            }
+            try {
+              previousCleanup?.()
+            } catch (error) {
+              nextCleanup()
+              throw error
+            }
+            cleanups.set(change.name, nextCleanup)
+            undo.push(() => {
+              nextCleanup()
+              cleanups.set(change.name, apply(change.name, change.previous))
+            })
+          }
+        },
+        () => {
+          for (let index = undo.length - 1; index >= 0; index -= 1) undo[index]?.()
+          undo.length = 0
+        },
+      ]
+    },
+  )
+  registerCompiledCleanup(() => {
+    controlledCleanup?.()
+    for (const cleanup of cleanups.values()) cleanup()
+  })
+  return restoreAfterChildren
+}

package/src/state-slot.ts

@@ -0,0 +1,132 @@
+import type { SourceMask } from './source-mask.ts'
+
+export type StateUpdate<T> = T | ((previous: T) => T)
+
+export interface DeferredStateWrite<T> {
+  readonly slot: object
+  readonly revision: number
+  readonly update: StateUpdate<T>
+  readonly commit: (update: StateUpdate<T>) => void
+  readonly currentRevision: () => number
+}
+
+export type StateWriteInterceptor = <T>(write: DeferredStateWrite<T>) => boolean
+
+let stateWriteInterceptor: StateWriteInterceptor | undefined
+
+export function installStateWriteInterceptor(interceptor: StateWriteInterceptor): void {
+  stateWriteInterceptor = interceptor
+}
+
+export interface StateSlot<T> {
+  readonly get: () => T
+  readonly set: (update: StateUpdate<T>) => void
+  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,
+  initialValue: T,
+  assertWritable?: () => void,
+): StateSlot<T> {
+  let value = initialValue
+  let revision = 0
+  let token: object | undefined
+
+  const apply = (next: T): void => {
+    if (Object.is(value, next)) return
+
+    value = next
+    revision += 1
+    invalidate(source)
+  }
+
+  return {
+    get: () => value,
+    set: (update) => {
+      assertWritable?.()
+      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)
+    },
+  }
+}

package/src/testing.ts

@@ -0,0 +1,27 @@
+import { readCompiledOwnerMetrics as readOwnerMetrics } from './compiled/core.ts'
+import {
+  beginActScope as beginSchedulerActScope,
+  endActScope as endSchedulerActScope,
+  flushScheduledTasks as flushSchedulerTasks,
+  hasScheduledTasks as schedulerHasTasks,
+} from './scheduler.ts'
+
+export function beginActScope(): void {
+  beginSchedulerActScope()
+}
+
+export function endActScope(): void {
+  endSchedulerActScope()
+}
+
+export function flushScheduledTasks(): number {
+  return flushSchedulerTasks()
+}
+
+export function hasScheduledTasks(): boolean {
+  return schedulerHasTasks()
+}
+
+export function readCompiledOwnerMetrics(): ReturnType<typeof readOwnerMetrics> {
+  return readOwnerMetrics()
+}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,OAAO,EACP,MAAM,EACN,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,2BAA2B,EAC3B,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,yBAAyB,EACzB,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,aAAa,EACb,OAAO,EACP,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,GAAG,EACH,WAAW,EACX,UAAU,EACV,SAAS,EACT,cAAc,EACd,KAAK,EACL,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,OAAO,EACP,oBAAoB,EACpB,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EACV,eAAe,EACf,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,EACb,UAAU,EACV,iBAAiB,GAClB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,EACL,aAAa,EACb,QAAQ,EACR,CAAC,EACD,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,kBAAkB,EAClB,gBAAgB,EAChB,yBAAyB,EACzB,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AACxF,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,2HAA2H;AAC3H,mCAAmC;AAEnC,OAAO,EACL,OAAO,EACP,MAAM,EACN,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,2BAA2B,EAC3B,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,yBAAyB,EACzB,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,aAAa,EACb,OAAO,EACP,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,GAAG,EACH,WAAW,EACX,UAAU,EACV,SAAS,EACT,cAAc,EACd,KAAK,EACL,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,OAAO,EACP,oBAAoB,EACpB,IAAI,GAGL,MAAM,oBAAoB,CAAA;AAW3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,EACL,aAAa,EACb,QAAQ,EACR,CAAC,GAIF,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAE,MAAM,EAAmB,MAAM,UAAU,CAAA;AAClD,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,kBAAkB,EAClB,gBAAgB,EAChB,yBAAyB,EACzB,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,iBAAiB,GAGlB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAsC,MAAM,WAAW,CAAA;AACxF,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,EAAmB,MAAM,kBAAkB,CAAA;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA"}