jq79 0.5.5 → 0.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jq79",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Mini reactive component library: single-file components, Svelte-style setup scripts, fine-grained proxy reactivity. Single-file build, zero dependencies.",
   "keywords": [
     "reactive",

package/src/jq79.ts

@@ -127,6 +127,25 @@ const reportedExprErrors = new Set<string>()
 let pendingScripts = 0
 let flushScheduled = false
 
+// everything else an expression can throw - overwhelmingly a member access on
+// an undefined value, `{{ game.is.loaded }}` over a game with no `is`. Unlike a
+// missing name it needs no deferral and gets none: the engine already caught a
+// real exception and wrote the message, so there is nothing left to decide and
+// it is reported where it throws, as an error rather than a warning.
+//
+// That means a value still on its way is reported too - `{{ user.name }}` over
+// a user that a fetch will fill renders empty and says so, once. It is a
+// deliberate trade against the silence it replaces, which hid a render that was
+// actively wrong (a thrown `:disabled` is falsy, so the button rendered
+// *enabled*). The fix is the one the message names: `user?.name`, or `:if`.
+//
+// Deduped by expression text alone. A `:each` over 1000 rows throws 1000 times
+// per render and the Set is what keeps that to one line; keying finer - by
+// message too, as the missing-name queue does - would let one broken path
+// report once per distinct message. There is no queue behind it because there
+// is nothing to re-check, and so nothing that could retain a live scope
+const reportedFailedExprs = new Set<string>()
+
 const flushExprReports = () => {
   flushScheduled = false
   if (pendingScripts > 0) return // a script started meanwhile; its release re-schedules
@@ -161,8 +180,22 @@ const trackScript = (settled: Promise<unknown>) => {
   settled.then(release, release)
 }
 
+// console.error, not warn: a name that resolves nowhere is a warning because
+// the runtime can only say the name is absent, while this one caught a real
+// exception - it has a message the engine wrote, and the expression rendered as
+// nothing instead of doing what it says
+const reportFailedExpr = (expr: string, error: unknown) => {
+  if (reportedFailedExprs.has(expr)) return
+  reportedFailedExprs.add(expr)
+  const message = (error as Error)?.message || String(error)
+  console.error(
+    `jq79: ${message} - evaluating "${expr}". The expression rendered as nothing. ` +
+    `If the value arrives later, guard it - "a?.b", or :if on the element.`
+  )
+}
+
 const reportExprError = (expr: string, scope: Record<string, any>, error: unknown) => {
-  if (!(error instanceof ReferenceError)) return
+  if (!(error instanceof ReferenceError)) return reportFailedExpr(expr, error)
   const match = MISSING_NAME_RE.exec(error.message)
   const name = match?.[1] ?? match?.[2]
   if (!name) return // an engine whose wording we don't know: stay quiet, as before
@@ -2276,6 +2309,7 @@ export class Component79 {
     // a different key
     reportedExprErrors.clear()
     pendingReports.clear()
+    reportedFailedExprs.clear()
     const marker = this.startMarker
     const rendered = !!(marker && this.content)