@tishlang/tish 1.0.28 → 1.0.33

package/crates/tish_jsx_web/vendor/Lattish.tish

@@ -1,362 +0,0 @@
-// Lattish: Lattish runtime for compiled JSX. Publish to npm; consumed by tish and tish-playground.
-// With `tish compile --target js --jsx vdom`, the compiler injects a prelude that sets
-// window.__LATTISH_JSX_VDOM and __lattishVdomPatch; createRoot then reconciles vnodes.
-
-export let Fragment = Symbol("Lattish.Fragment")
-
-fn __lattishAppend(parent, c) {
-  if (c === null || c === undefined) {
-    return
-  }
-  if (Array.isArray(c)) {
-    let i = 0
-    while (i < c.length) {
-      __lattishAppend(parent, c[i])
-      i = i + 1
-    }
-    return
-  }
-  if (typeof c === "string") {
-    parent.appendChild(document.createTextNode(c))
-  } else {
-    parent.appendChild(c)
-  }
-}
-
-export fn h(tag, props, children) {
-  if (children === undefined || children === null) {
-    children = []
-  }
-  if (typeof tag === "function") {
-    let p = props && props !== null ? props : {}
-    if (children.length > 0) {
-      let newProps = {}
-      let keys = Object.keys(p)
-      let i = 0
-      while (i < keys.length) {
-        newProps[keys[i]] = p[keys[i]]
-        i = i + 1
-      }
-      newProps.children = children
-      p = newProps
-    }
-    return tag(p)
-  }
-  if (tag === Fragment) {
-    let f = document.createDocumentFragment()
-    let i = 0
-    while (i < children.length) {
-      __lattishAppend(f, children[i])
-      i = i + 1
-    }
-    return f
-  }
-  let el = document.createElement(tag)
-  let refVal = null
-  if (props && props !== null) {
-    let keys = Object.keys(props)
-    let ki = 0
-    while (ki < keys.length) {
-      let k = keys[ki]
-      let v = props[k]
-      if (k === "ref") {
-        refVal = v
-      } else {
-        if (k === "disabled") {
-          el.disabled = !!v
-        } else {
-        if (v === true) {
-          el.setAttribute(k, k)
-        } else {
-          if (v !== false && v !== null && v !== undefined) {
-            if (k === "class" || k === "className") {
-              el.className = v
-            } else {
-              if (k.length >= 3 && k[0] === "o" && k[1] === "n" && typeof v === "function") {
-                let eventType = k.slice(2).toLowerCase()
-                el.addEventListener(eventType, v)
-              } else {
-                if (k === "value" && (tag === "input" || tag === "textarea")) {
-                  el.value = v
-                } else {
-                  if (k !== "ref") {
-                    el.setAttribute(k, String(v))
-                  }
-                }
-              }
-            }
-          }
-        }
-        }
-      }
-      ki = ki + 1
-    }
-  }
-  let ci = 0
-  while (ci < children.length) {
-    __lattishAppend(el, children[ci])
-    ci = ci + 1
-  }
-  if (refVal !== null && refVal !== undefined && typeof refVal === "object") {
-    refVal.current = el
-  }
-  return el
-}
-
-export fn text(s) {
-  return s
-}
-
-let __state = []
-let __cursor = 0
-let __container = null
-let __App = null
-let __rootVnode = null
-
-let __memoSlots = []
-let __refSlots = []
-let __layoutEffectSlots = []
-let __effectSlots = []
-
-let __flushScheduled = false
-let __batchDepth = 0
-let __dirtyFromBatch = false
-let __effectsMicrotaskScheduled = false
-
-fn __depsChanged(prev, next) {
-  if (prev === null) {
-    return true
-  }
-  if (next === null || prev === null) {
-    return true
-  }
-  if (prev.length !== next.length) {
-    return true
-  }
-  let j = 0
-  while (j < next.length) {
-    if (prev[j] !== next[j]) {
-      return true
-    }
-    j = j + 1
-  }
-  return false
-}
-
-fn __runLayoutEffects() {
-  let i = 0
-  while (i < __layoutEffectSlots.length) {
-    let s = __layoutEffectSlots[i]
-    if (s && s.pending) {
-      s.pending = false
-      if (s.cleanup) {
-        s.cleanup()
-        s.cleanup = null
-      }
-      let c = s.effect()
-      if (typeof c === "function") {
-        s.cleanup = c
-      }
-    }
-    i = i + 1
-  }
-}
-
-fn __scheduleEffectsFlush() {
-  if (__effectsMicrotaskScheduled) {
-    return
-  }
-  __effectsMicrotaskScheduled = true
-  queueMicrotask(() => {
-    __effectsMicrotaskScheduled = false
-    let i = 0
-    while (i < __effectSlots.length) {
-      let s = __effectSlots[i]
-      if (s && s.pending) {
-        s.pending = false
-        if (s.cleanup) {
-          s.cleanup()
-          s.cleanup = null
-        }
-        let c = s.effect()
-        if (typeof c === "function") {
-          s.cleanup = c
-        }
-      }
-      i = i + 1
-    }
-  })
-}
-
-/// Runs synchronously after DOM is updated (before paint in typical browsers).
-export fn useLayoutEffect(effect, deps) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __layoutEffectSlots.length) {
-    __layoutEffectSlots.push(null)
-  }
-  let slot = __layoutEffectSlots[i]
-  if (slot === null) {
-    slot = { deps: null, effect: null, cleanup: null, pending: false }
-    __layoutEffectSlots[i] = slot
-  }
-  if (__depsChanged(slot.deps, deps)) {
-    slot.deps = deps
-    slot.effect = effect
-    slot.pending = true
-  }
-}
-
-/// Runs after paint (microtask after flush).
-export fn useEffect(effect, deps) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __effectSlots.length) {
-    __effectSlots.push(null)
-  }
-  let slot = __effectSlots[i]
-  if (slot === null) {
-    slot = { deps: null, effect: null, cleanup: null, pending: false }
-    __effectSlots[i] = slot
-  }
-  if (__depsChanged(slot.deps, deps)) {
-    slot.deps = deps
-    slot.effect = effect
-    slot.pending = true
-    __scheduleEffectsFlush()
-  }
-}
-
-fn __usingVdom() {
-  return typeof window !== "undefined" && window.__LATTISH_JSX_VDOM && window.__lattishVdomPatch
-}
-
-fn __flushRender() {
-  __cursor = 0
-  if (__container && __App) {
-    if (__usingVdom()) {
-      let newTree = __App()
-      window.__lattishVdomPatch(__container, __rootVnode, newTree)
-      __rootVnode = newTree
-    } else {
-      let el = __App()
-      __container.replaceChildren(el)
-      __rootVnode = null
-    }
-    __runLayoutEffects()
-    __scheduleEffectsFlush()
-  }
-}
-
-fn __scheduleFlush() {
-  if (__batchDepth > 0) {
-    __dirtyFromBatch = true
-    return
-  }
-  if (__flushScheduled) {
-    return
-  }
-  __flushScheduled = true
-  queueMicrotask(() => {
-    __flushScheduled = false
-    __flushRender()
-  })
-}
-
-export fn unstable_batchedUpdates(run) {
-  __batchDepth = __batchDepth + 1
-  run()
-  __batchDepth = __batchDepth - 1
-  if (__batchDepth === 0 && __dirtyFromBatch) {
-    __dirtyFromBatch = false
-    __flushScheduled = false
-    __flushRender()
-  }
-}
-
-export fn useState(init) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  if (i >= __state.length) {
-    __state.push(init)
-  }
-  fn setState(v) {
-    if (typeof v === "function") {
-      __state[i] = v(__state[i])
-    } else {
-      __state[i] = v
-    }
-    __scheduleFlush()
-  }
-  return [__state[i], setState]
-}
-
-export fn useMemo(deps, factory) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __memoSlots.length) {
-    __memoSlots.push(null)
-  }
-  let slot = __memoSlots[i]
-  let stale = true
-  if (slot) {
-    stale = false
-    if (slot.deps.length !== deps.length) {
-      stale = true
-    } else {
-      let j = 0
-      while (j < deps.length) {
-        if (slot.deps[j] !== deps[j]) {
-          stale = true
-          break
-        }
-        j = j + 1
-      }
-    }
-  }
-  if (stale) {
-    __memoSlots[i] = { deps: deps, value: factory() }
-  }
-  return __memoSlots[i].value
-}
-
-export fn useRef(initial) {
-  let i = __cursor
-  __cursor = __cursor + 1
-  while (i >= __refSlots.length) {
-    __refSlots.push(null)
-  }
-  if (__refSlots[i] === null) {
-    __refSlots[i] = { current: initial }
-  }
-  return __refSlots[i]
-}
-
-export fn createRoot(container) {
-  fn render(App) {
-    __container = container
-    __App = App
-    __state = []
-    __memoSlots = []
-    __refSlots = []
-    __layoutEffectSlots = []
-    __effectSlots = []
-    __cursor = 0
-    __flushScheduled = false
-    __batchDepth = 0
-    __dirtyFromBatch = false
-    __effectsMicrotaskScheduled = false
-    __rootVnode = null
-    if (__usingVdom()) {
-      __rootVnode = App()
-      window.__lattishVdomPatch(container, null, __rootVnode)
-    } else {
-      let el = App()
-      container.replaceChildren(el)
-    }
-    __cursor = 0
-    __runLayoutEffects()
-    __scheduleEffectsFlush()
-  }
-  return { render: render }
-}