@jarenjs/view 0.49.2 → 0.66.1

package/README.md

@@ -168,14 +168,35 @@ The patcher's first check is `oldVnode === newVnode` — a reference-equal subtr
 
 Measured, not claimed — run `npm run benchmark:view` for your own numbers, and the [benchmarks page](https://jarenjs.github.io/#/benchmarks?suite=view) publishes the latest full run with its date and machine. Two different costs get measured on a 1000-row table (output equality with React and preact asserted before timing), and keeping them apart is what makes the numbers readable:
 
-- **The format.** A vnode is a tagged array — an array literal plus a plain object — and the renderer, patcher and SSR accept it from any producer. A **hand-written view building tagged arrays directly is the fastest element builder in the table: ~<!--bm:view.vsReact-->2.2<!--/bm-->× faster than React's production `createElement`**, ~<!--bm:view.vsPreact-->2.8<!--/bm-->× faster than preact's `h()`. Writing views by hand is fully supported; the stylesheet is opt-in per view.
-- **The engine.** A JSLT stylesheet is a view as *data* — schema-validated, serializable, storable, and renderable from an untrusted source through the [safe profile](#untrusted-views-the-safe-profile) — and running that document through the generic dispatcher costs **~<!--bm:view.engineCost-->23.2<!--/bm-->× the hand-written build**. That is the published price of a capability none of the rivals has a mode for: a JSX view is code by construction, so there is no data-driven React number to compare against.
+- **The format.** A vnode is a tagged array — an array literal plus a plain object — and the renderer, patcher and SSR accept it from any producer. A **hand-written view building tagged arrays directly is the fastest element builder in the table: ~<!--fact:view.vsReact-->2.2<!--/fact-->× faster than React's production `createElement`**, ~<!--fact:view.vsPreact-->2.8<!--/fact-->× faster than preact's `h()`. Writing views by hand is fully supported; the stylesheet is opt-in per view.
+- **The engine.** A JSLT stylesheet is a view as *data* — schema-validated, serializable, storable, and renderable from an untrusted source through the [safe profile](#untrusted-views-the-safe-profile) — and running that document through the generic dispatcher costs **~<!--fact:view.engineCost-->23.2<!--/fact-->× the hand-written build**. That is the published price of a capability none of the rivals has a mode for: a JSX view is code by construction, so there is no data-driven React number to compare against.
 - **The re-render path.** An **unchanged document re-renders in O(1)** — the memoized transform returns the previous output by reference and the patcher skips it whole — and the vnode-level `memo` marker gives hand-written producers the same subtree skip (~12× over the child scan). For a one-row copy-on-write update the memo cuts the stylesheet frame ~1.5× against its own no-memo path; at this table size the hand-written view plus a full diff is still the fastest frame outright, and that is on the page too. SSR lands within ~1.6–2.8× of `preact-render-to-string` depending on the route, on byte-identical output.
 
 When a producer cannot preserve the reference — it rebuilds its tree but knows a region did not change — the **`memo` prop** says so declaratively (VIEW-FORMAT §5.5): two same-node vnodes carrying equal `memo` values skip reconciliation exactly like reference-equal ones. It is a producer-owned assertion, `key`'s sibling: equal markers promise identical subtrees, and a violated promise means stale output. Measured on a reallocated parent over 10 000 shared children, the marker removes the whole per-child scan: about **448 µs** to walk the children looking for `===` skips versus about **41 µs** with the marker — **10.9×**, and the gap widens with the child count (`npm run benchmark:view`). `@jarenjs/charts`' streaming sessions are the reference consumer.
 
 Children reconcile with a head/tail sweep plus a key map for the middle: keyed siblings move their real DOM nodes instead of recreating them; unkeyed siblings patch positionally. Event bindings are data stored on the node behind one shared proxy listener per event type — re-rendering rebinds by assignment, never through `addEventListener`.
 
+## Exports
+
+Every subpath a consumer can import, derived from the manifest by
+`npm run docs:derive` (`npm run docs:check` fails when the two drift):
+
+<!--fact:exports.view-->
+| Import | Kind | Declarations |
+|---|---|---|
+| `@jarenjs/view` | JavaScript | declared |
+| `@jarenjs/view/helpers` | JavaScript | declared |
+| `@jarenjs/view/helpers/index` | JavaScript | declared |
+| `@jarenjs/view/helpers/memo` | JavaScript | declared |
+| `@jarenjs/view/helpers/metrics` | JavaScript | declared |
+| `@jarenjs/view/helpers/svg` | JavaScript | declared |
+| `@jarenjs/view/helpers/theme` | JavaScript | declared |
+| `@jarenjs/view/helpers/url` | JavaScript | declared |
+| `@jarenjs/view/schemas/jaren-vnode-safe.schema.json` | schema | — |
+| `@jarenjs/view/schemas/jaren-vnode.schema.json` | schema | — |
+| `@jarenjs/view/package.json` | metadata | — |
+<!--/fact-->
+
 ## Development
 
 Unit tests live in `test/view/` at the repository root (`npm run test:view`), including the minimal DOM stub they run against. See the repository [README](../../README.md) for the full suite documentation and [ROADMAP](../../docs/ROADMAP.md) for planned work: fragment roots, DOM-adopting hydration, and the memoized rule-output layer that turns JSLT sharing into cross-frame skipping.

package/docs/VIEW-FORMAT.md

@@ -225,6 +225,11 @@ patching renderer would build: text and attribute values escaped (`&`,
 no output, boolean and style props serialized per §3. Serialization is
 pure: no state, no DOM, safe in any runtime.
 
+In trusted mode, a `textarea` carrying a `value` prop serializes that
+value as escaped text content, overriding its children; nullish values
+produce empty text. A leading newline is preserved through HTML parsing.
+Safe mode keeps its attribute-only policy (§8).
+
 Hydration in 0.1 is a client-side first render into the same container
 (empty and rebuild). Adopting existing server-rendered DOM is a
 roadmap item, not part of this contract.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/view",
   "private": false,
-  "version": "0.49.2",
+  "version": "0.66.1",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -53,7 +53,7 @@
     "ssr"
   ],
   "dependencies": {
-    "@jarenjs/core": "^0.49.2"
+    "@jarenjs/core": "^0.66.1"
   },
   "scripts": {
     "build": "npm run build:types",

package/src/dom.js

@@ -1104,8 +1104,9 @@ function patchChildren(ctx, parent, oldCh, newCh, ns) {
       oldStart++; newStart++;
     }
     else if (isSameNode(oE, nE)) {
-      patchNode(ctx, parent, oldDom[oldEnd], oE, nE, ns);
-      tailRef = oldDom[oldEnd];
+      // A widget may replace its host while keeping its vnode key/tag.
+      // Future insertions must anchor to the live replacement.
+      tailRef = patchNode(ctx, parent, oldDom[oldEnd], oE, nE, ns);
       oldEnd--; newEnd--;
     }
     else if (isSameNode(oS, nE)) {

package/src/helpers/theme.js

@@ -51,11 +51,12 @@ export function resolveTheme(themes, prefix, nameOrOverrides = 'default', hostVa
   let vars = null;
   if (nameOrOverrides === 'host' && hostVars) nameOrOverrides = { vars: hostVars };
   if (typeof nameOrOverrides === 'string') {
-    name = themes[nameOrOverrides] ? nameOrOverrides : 'default';
+    name = Object.hasOwn(themes, nameOrOverrides) && themes[nameOrOverrides] ? nameOrOverrides : 'default';
     base = themes[name];
   }
   else if (nameOrOverrides && typeof nameOrOverrides === 'object') {
-    if (typeof nameOrOverrides.theme === 'string' && themes[nameOrOverrides.theme]) {
+    if (typeof nameOrOverrides.theme === 'string'
+      && Object.hasOwn(themes, nameOrOverrides.theme) && themes[nameOrOverrides.theme]) {
       name = nameOrOverrides.theme;
       base = themes[name];
     }

package/src/html.js

@@ -29,6 +29,9 @@ const VOID_ELEMENTS = new Set([
 /** Props that never serialize to markup. */
 const SKIP_PROPS = new Set(['key', 'on', 'memo']);
 
+/** A controlled textarea's value is its text content in HTML markup. */
+const TEXTAREA_SKIP_PROPS = new Set([...SKIP_PROPS, 'value']);
+
 /** Widget-vnode props that configure the widget, not the host element. */
 const WIDGET_SKIP_PROPS = new Set(['key', 'on', 'memo', 'name', 'props', 'tag']);
 
@@ -184,11 +187,19 @@ function renderNode(vnode, widgets, policy, onUnsafe) {
   if (policy !== null && onUnsafe !== null && props.on !== undefined) {
     onUnsafe({ kind: 'event', name: 'on' });
   }
-  let out = '<' + tag + serializeProps(props, SKIP_PROPS, policy, onUnsafe);
+  const controlledTextarea = policy === null && tag === 'textarea' && 'value' in props;
+  let out = '<' + tag + serializeProps(props,
+    controlledTextarea ? TEXTAREA_SKIP_PROPS : SKIP_PROPS, policy, onUnsafe);
   if (VOID_ELEMENTS.has(tag)) {
     return out + '>';
   }
   out += '>';
+  if (controlledTextarea) {
+    const value = props.value == null ? '' : String(props.value);
+    // HTML normalizes CR/CRLF to LF and consumes one leading LF in a
+    // textarea. Protect an authored newline with an extra LF.
+    return out + (/^[\r\n]/.test(value) ? '\n' : '') + escapeText(value) + '</' + tag + '>';
+  }
   const children = childrenOf(vnode);
   for (let i = 0; i < children.length; i++) {
     out += renderNode(children[i], widgets, policy, onUnsafe);