@sigx/lynx-runtime 0.4.5 → 0.4.7

package/dist/nodeOps.d.ts

@@ -10,5 +10,13 @@ import type { RendererOptions } from '@sigx/runtime-core/internals';
 import { ShadowElement } from './shadow-element.js';
 export type LynxNode = ShadowElement;
 export type LynxElement = ShadowElement;
+/**
+ * Test-only: clear the module-level per-element maps above. They are keyed by
+ * element id, so a test suite that recycles ids via `resetShadowState()`
+ * without this reset would resolve stale slots from earlier tests (and skip
+ * pushing SET_EVENT for "already registered" events). Production code never
+ * recycles ids, so this is never called outside tests.
+ */
+export declare function resetNodeOpsState(): void;
 export declare function resolveClass(el: ShadowElement): string;
 export declare const nodeOps: RendererOptions<ShadowElement, ShadowElement>;

package/dist/nodeOps.js

@@ -55,6 +55,18 @@ const elementEventSigns = new Map();
 // to bindEvent:tap), we keep one sign in __AddEvent and dispatch to all handlers from
 // a multi-handler wrapper in the BG registry.
 const nativeEventSlots = new Map();
+/**
+ * Test-only: clear the module-level per-element maps above. They are keyed by
+ * element id, so a test suite that recycles ids via `resetShadowState()`
+ * without this reset would resolve stale slots from earlier tests (and skip
+ * pushing SET_EVENT for "already registered" events). Production code never
+ * recycles ids, so this is never called outside tests.
+ */
+export function resetNodeOpsState() {
+    sentWorklets.clear();
+    elementEventSigns.clear();
+    nativeEventSlots.clear();
+}
 // ---------------------------------------------------------------------------
 // Style normalisation — numeric values → 'Npx' (Lynx requires units)
 // ---------------------------------------------------------------------------
@@ -229,8 +241,19 @@ export const nodeOps = {
                 }
                 let slot = elSlots.get(nativeKey);
                 if (!slot) {
+                    // Record what the user typed so the `value` patch branch below can
+                    // tell a model echo apart from a programmatic write (#143).
+                    const trackInputValue = event.name === 'input'
+                        && (el.type === 'input' || el.type === 'textarea');
                     // First handler for this native event — register with Lynx.
                     const sign = register((data) => {
+                        if (trackInputValue) {
+                            const v = data?.detail?.value;
+                            // Normalize to a string ('' for nullish) — the `value` patch
+                            // branch compares and stores the same representation, and
+                            // setValue only ever pushes strings.
+                            el._lastInputValue = v == null ? '' : String(v);
+                        }
                         // Dispatch to all handlers registered for this slot.
                         const s = elSlots.get(nativeKey);
                         if (s) {
@@ -293,6 +316,33 @@ export const nodeOps = {
         else if (key === 'id') {
             pushOp(OP.SET_ID, el.id, nextValue);
         }
+        else if (key === 'value' && (el.type === 'input' || el.type === 'textarea')) {
+            pushOp(OP.SET_PROP, el.id, key, nextValue);
+            // The native field treats the `value` attribute as initial-only once
+            // the user has edited it — programmatic writes (clear-on-send, editor
+            // toolbar inserts) must additionally go through the element's
+            // `setValue` UI method or the visible text never changes (#143).
+            // Skip during initial mount (`el.parent == null`: props are patched
+            // before insertion, and the attribute covers the initial value) — NOT
+            // by `_prevValue == null`, which would also skip legitimate post-mount
+            // transitions like value={null} → value={'text'}. Also skip the model
+            // echo (the re-render caused by the user's own typing, where the new
+            // value is exactly what the input event just reported) so cursor/IME
+            // composition isn't disturbed while typing.
+            // Normalize to a string ('' for nullish) on BOTH sides of the
+            // comparison — `value` is typed string on input/textarea but user code
+            // can write a number/boolean by mistake, and setValue is a native
+            // text-field method that expects a string. Any other representation
+            // would desync `_lastInputValue` from the native field and re-invoke
+            // redundantly on later renders.
+            const next = nextValue == null ? '' : String(nextValue);
+            if (el.parent != null && next !== el._lastInputValue) {
+                pushOp(OP.INVOKE_UI_METHOD, el.id, 'setValue', { value: next });
+                // The programmatic write replaces whatever the user had typed; track
+                // it so the next echo comparison stays correct.
+                el._lastInputValue = next;
+            }
+        }
         else {
             pushOp(OP.SET_PROP, el.id, key, nextValue);
         }

package/dist/shadow-element.d.ts

@@ -19,6 +19,7 @@ export declare class ShadowElement {
     _vShowHidden: boolean;
     _baseClass: string;
     _transitionClasses: Set<string>;
+    _lastInputValue: string | undefined;
     constructor(type: string, forceId?: number);
     insertBefore(child: ShadowElement, anchor: ShadowElement | null): void;
     removeChild(child: ShadowElement): void;

package/dist/shadow-element.js

@@ -23,6 +23,16 @@ export class ShadowElement {
     // Class management for Transition support.
     _baseClass = '';
     _transitionClasses = new Set();
+    // Last text known to be in the native <input>/<textarea>: recorded from the
+    // native input event by nodeOps, and updated by post-mount programmatic
+    // writes that go through the setValue UI method. Used to tell a model echo
+    // (signal update caused by typing) apart from a programmatic write
+    // (clear-on-send, toolbar insert) — only the latter must be pushed back to
+    // the native field. Always stored as a string ('' for nullish, matching
+    // what setValue pushes); `undefined` until the first input event or
+    // setValue-pushing write (the first-render `value` attribute does NOT
+    // initialize it).
+    _lastInputValue = undefined;
     constructor(type, forceId) {
         this.id = forceId !== undefined ? forceId : ShadowElement.nextId++;
         this.type = type;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigx/lynx-runtime",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Lynx renderer for SignalX (background thread)",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,7 +41,7 @@
   "dependencies": {
     "@sigx/runtime-core": "^0.4.8",
     "@sigx/reactivity": "^0.4.8",
-    "@sigx/lynx-runtime-internal": "^0.4.5"
+    "@sigx/lynx-runtime-internal": "^0.4.7"
   },
   "peerDependencies": {
     "@lynx-js/types": "*"