@tishlang/tish 1.0.7 → 1.0.11

package/crates/tish_jsx_web/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "tish_jsx_web"
+version = "0.1.0"
+edition = "2021"
+description = "JSX / DOM runtime snippets for Tish JS target only (not used by native)"
+
+[dependencies]

package/crates/tish_jsx_web/README.md

@@ -0,0 +1,18 @@
+# tish_jsx_web
+
+Web-only crate for the Tish JS backend:
+
+- **`VDOM_PRELUDE`** — vnode helpers + `window.__lattishVdomPatch` + `window.__LATTISH_JSX_VDOM` for `--jsx vdom`.
+
+Native / non-JS compiler targets must not depend on this crate; only `tish_compile_js` pulls it in.
+
+## Vendor runtime
+
+`vendor/Lattish.tish` is a copy refreshed from the **lattish** npm package. Run `just refresh-lattish` to update from the sibling lattish package.
+
+## JSX modes (`--jsx`)
+
+| Mode | JSX lowers to | Preamble |
+|------|----------------|----------|
+| `lattish` (default) | Lattish-style JSX lowering | none — merge `Lattish.tish` by importing any export you need (or `import {} from "lattish"` for JSX-only) |
+| `vdom` | `__vdom_h(...)` | VDOM prelude; Lattish `createRoot` patches the tree when `window.__LATTISH_JSX_VDOM` is set |

package/crates/tish_jsx_web/src/lib.rs

@@ -0,0 +1,157 @@
+//! Web-only JSX helpers for `tish compile --target js`.
+//! Native and WASM native paths must not depend on this crate.
+
+/// VDOM: vnode `__vdom_h` + `window.__lattishVdomPatch` for Lattish batched flush.
+pub const VDOM_PRELUDE: &str = r#"window.__LATTISH_JSX_VDOM = true;
+const __Fragment = Symbol('Fragment');
+function __vdom_h(tag, props, children) {
+  if (children === undefined || children === null) children = [];
+  if (!Array.isArray(children)) children = [children];
+  return { tag: tag, props: props || null, children: children, _el: null };
+}
+function __vdom_flatten(ch) {
+  const out = [];
+  function w(c) {
+    if (c == null) return;
+    if (Array.isArray(c)) { for (let i = 0; i < c.length; i++) w(c[i]); return; }
+    if (typeof c === 'object' && c && c.tag === __Fragment) {
+      const inner = c.children;
+      if (Array.isArray(inner)) for (let i = 0; i < inner.length; i++) w(inner[i]);
+      return;
+    }
+    out.push(c);
+  }
+  if (Array.isArray(ch)) for (let i = 0; i < ch.length; i++) w(ch[i]);
+  return out;
+}
+function __vdom_mount(v) {
+  if (typeof v === 'string') return document.createTextNode(v);
+  if (v.tag === __Fragment) {
+    const f = document.createDocumentFragment();
+    const ch = __vdom_flatten(v.children);
+    for (let i = 0; i < ch.length; i++) f.appendChild(__vdom_mount(ch[i]));
+    return f;
+  }
+  const el = document.createElement(v.tag);
+  const p = v.props || {};
+  for (const k of Object.keys(p)) {
+    const val = p[k];
+    if (val === true) el.setAttribute(k, k);
+    else if (val !== false && val != null) {
+      if (k === 'class' || k === 'className') el.className = val;
+      else if (k.startsWith('on') && typeof val === 'function') el[k.toLowerCase()] = val;
+      else if (k === 'value' && (v.tag === 'input' || v.tag === 'textarea' || v.tag === 'select')) el.value = val;
+      else el.setAttribute(k, String(val));
+    }
+  }
+  const ch = __vdom_flatten(v.children);
+  for (let i = 0; i < ch.length; i++) el.appendChild(__vdom_mount(ch[i]));
+  v._el = el;
+  return el;
+}
+function __vdomPatchEl(el, ov, nv) {
+  if (!el || !ov || !nv) return false;
+  if (typeof nv === 'string') {
+    if (el.nodeType === 3) el.textContent = nv;
+    return true;
+  }
+  if (ov.tag !== nv.tag) return false;
+  nv._el = el;
+  const p = nv.props || {};
+  const op = ov.props || {};
+  for (const k of Object.keys(p)) {
+    if (p[k] !== op[k]) {
+      const val = p[k];
+      if (k === 'class' || k === 'className') el.className = val || '';
+      else if (k.startsWith('on')) el[k.toLowerCase()] = val || null;
+      else if (k === 'value' && (nv.tag === 'input' || nv.tag === 'textarea' || nv.tag === 'select')) {
+        if (el !== document.activeElement) el.value = val;
+      } else el.setAttribute(k, String(val));
+    }
+  }
+  const ocx = __vdom_flatten(ov.children);
+  const ncx = __vdom_flatten(nv.children);
+  let fullCh = ocx.length !== ncx.length;
+  if (!fullCh) {
+    for (let j = 0; j < ncx.length; j++) {
+      const o = ocx[j], n = ncx[j];
+      if (typeof n === 'string') { if (typeof o !== 'string') fullCh = true; }
+      else if (typeof o === 'string') fullCh = true;
+      else if (!o || o.tag !== n.tag) fullCh = true;
+      if (fullCh) break;
+    }
+  }
+  if (fullCh) {
+    const nodes = [];
+    for (let j = 0; j < ncx.length; j++) nodes.push(__vdom_mount(ncx[j]));
+    el.replaceChildren(...nodes);
+    return true;
+  }
+  let i = 0;
+  while (i < ncx.length) {
+    const o = ocx[i], n = ncx[i];
+    const childEl = el.childNodes[i];
+    if (n == null) {
+      if (childEl) el.removeChild(childEl);
+      i++;
+      continue;
+    }
+    if (o == null) {
+      el.appendChild(__vdom_mount(n));
+      i++;
+      continue;
+    }
+    if (typeof n === 'string') {
+      if (childEl && childEl.nodeType === 3) childEl.textContent = n;
+      else {
+        const m = __vdom_mount(n);
+        if (childEl) el.replaceChild(m, childEl);
+        else el.appendChild(m);
+      }
+      i++;
+      continue;
+    }
+    if (typeof o === 'string' || o.tag !== n.tag) {
+      const m = __vdom_mount(n);
+      if (childEl) el.replaceChild(m, childEl);
+      else el.appendChild(m);
+      i++;
+      continue;
+    }
+    if (!childEl || !__vdomPatchEl(childEl, o, n)) {
+      const m = __vdom_mount(n);
+      if (childEl) el.replaceChild(m, childEl);
+      else el.appendChild(m);
+    }
+    i++;
+  }
+  return true;
+}
+window.__lattishVdomPatch = function(container, oldTree, newTree) {
+  try {
+    if (oldTree == null) {
+      container.replaceChildren(__vdom_mount(newTree));
+      return;
+    }
+    const el = container.firstChild;
+    if (!el) {
+      container.appendChild(__vdom_mount(newTree));
+      return;
+    }
+    if (typeof newTree === 'string' || oldTree.tag !== newTree.tag) {
+      container.replaceChildren(__vdom_mount(newTree));
+      return;
+    }
+    if (!__vdomPatchEl(el, oldTree, newTree)) {
+      container.replaceChildren(__vdom_mount(newTree));
+    }
+  } catch (err) {
+    console.warn('Lattish VDOM patch failed, full remount', err);
+    try {
+      container.replaceChildren(__vdom_mount(newTree));
+    } catch (e2) {
+      console.error('Lattish VDOM remount failed', e2);
+    }
+  }
+};
+"#;

package/crates/tish_jsx_web/vendor/Lattish.tish

@@ -0,0 +1,347 @@
+// 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 (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 }
+}

package/crates/tish_lexer/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "tish_lexer"
+version = "0.1.0"
+edition = "2021"
+description = "Tish lexer with indent normalization and tab/space handling"
+
+[dependencies]