gina 0.6.10 → 0.6.11-alpha.2

package/framework/v0.6.11-alpha.2/VERSION

@@ -0,0 +1 @@
+0.6.11-alpha.2

package/framework/{v0.6.10 → v0.6.11-alpha.2}/core/asset/plugin/dist/vendor/gina/js/gina.js

@@ -16600,6 +16600,59 @@ function ValidatorPlugin(rules, data, formId, culture) {
     var setCaretToPos = function ($el, pos) {
         setSelectionRange($el, pos, pos);
     }
+    /**
+     * commitCaret
+     * #B389 — commits the caret SYNCHRONOUSLY after a programmatic value
+     * rebuild and records the position on the element. Assigning `.value`
+     * collapses the selection to the END of the field (measured on WebKit
+     * and Chromium), and the deferred restore of the transient-readonly
+     * dance only runs two macrotasks later — so without a synchronous
+     * commit, any keystroke arriving inside that window reads a stale
+     * `selectionStart` and inserts at the wrong offset (scrambled fast
+     * input). The recorded position (`_ginaAcCaret`) is what the keydown
+     * interception trusts while a deferred restore is still in flight.
+     *
+     * @param {object} $el - HTMLElement
+     * @param {number} pos - caret position to commit
+     */
+    var commitCaret = function ($el, pos) {
+        setCaretToPos($el, pos);
+        $el._ginaAcCaret = pos;
+    }
+    /**
+     * queueCaretRestore
+     * #B389 — re-applies the transient readonly (the Safari autofill/
+     * autosuggest suppression — mechanism kept identical to the original
+     * dance) and queues the deferred caret restore. The restore re-asserts
+     * the LATEST committed caret (`_ginaAcCaret`) rather than the position
+     * captured at its own keystroke: a later keystroke may have advanced
+     * the caret while this restore sat in the queue, and re-applying a
+     * stale capture is what scrambled fast typing. `_ginaAcPending` counts
+     * restores in flight so the keydown interception knows when the
+     * element's own selection can be trusted again; the tracker is handed
+     * back (nulled) once the last pending restore has fired.
+     *
+     * @param {object} $el - HTMLElement
+     */
+    var queueCaretRestore = function ($el) {
+        $el._ginaAcPending = ($el._ginaAcPending || 0) + 1;
+        $el.setAttribute('readonly', 'readonly');
+        setTimeout(() => {
+            $el.removeAttribute('readonly');
+            setTimeout(() => {
+                // Guard on typeof — never truthiness: 0 is a valid caret
+                // position, and the cleared tracker is null.
+                if ( typeof($el._ginaAcCaret) == 'number' ) {
+                    setCaretToPos($el, $el._ginaAcCaret);
+                }
+                $el._ginaAcPending--;
+                if ( $el._ginaAcPending <= 0 ) {
+                    $el._ginaAcPending = 0;
+                    $el._ginaAcCaret = null;
+                }
+            }, 0);
+        }, 0);
+    }
 
     var isElementVisible = function($el) {
         return ($el.offsetWidth > 0 || $el.offsetHeight > 0 || $el === document.activeElement) ? true : false;
@@ -16641,6 +16694,15 @@ function ValidatorPlugin(rules, data, formId, culture) {
      * Gated to REAL Safari at the registerForLiveChecking call site (#B135):
      * Chromium UAs carry the Safari token but were never this workaround's
      * target — they get native behavior.
+     *
+     * Caret integrity (#B389): every value rebuild commits the caret
+     * SYNCHRONOUSLY (commitCaret) and records it on the element; the
+     * deferred restore of the readonly dance (queueCaretRestore) re-asserts
+     * the LATEST committed position, and while a restore is in flight the
+     * keydown handler trusts the recorded caret over the element's own
+     * selection — a `.value` assignment parks the selection at the end of
+     * the field, so a fast next keystroke would otherwise read a stale
+     * position and compose scrambled text.
      * @param {object} $el HTMLElement
      * @param {number} [liveCheckTimer] - live-check debounce handle, cleared per intercepted keystroke
      */
@@ -16680,35 +16742,55 @@ function ValidatorPlugin(rules, data, formId, culture) {
                     var $_el = e.currentTarget;
                     var str = e.currentTarget.value;
                     var posStart = $_el.selectionStart, posEnd = $_el.selectionEnd;
+                    // #B389 — while a deferred caret restore is in flight, the
+                    // element's own selection is NOT trustworthy: the last
+                    // rebuild parked the caret at the end of the field and the
+                    // restore only runs two macrotasks later. Trust the
+                    // committed caret instead, so consecutive fast keystrokes
+                    // compose the same string a native field would.
+                    if ( ($_el._ginaAcPending || 0) > 0 && typeof($_el._ginaAcCaret) == 'number' ) {
+                        posStart = posEnd = $_el._ginaAcCaret;
+                    }
                     $_el.removeAttribute('readonly');
                     //console.debug('pressed: '+ e.key+'('+ e.keyCode+')', ' S:'+posStart, ' E:'+posEnd, ' MAP: '+ JSON.stringify(keyboardMapping));
                     switch (e.keyCode) {
                         case 46: //Delete
                             if (posStart != posEnd) {
                                 $_el.value = str.substring(0, posStart) + str.substring(posEnd);
-                                if (posStart == 0) {
-                                    $_el.value = str.substring(posEnd+1);
-                                }
+                                // #B391 — the posStart == 0 override below ate one
+                                // char MORE than the selection (native Delete
+                                // removes the selection only): "XY" with [0,1)
+                                // selected must give "Y", not "". The generic
+                                // rebuild above is already correct at position 0.
+                                // if (posStart == 0) {
+                                //     $_el.value = str.substring(posEnd+1);
+                                // }
                             } else if (posStart == 0) {
                                 $_el.value = str.substring(posStart+1);
                             } else {
                                 $_el.value = str.substring(0, posStart) + str.substring(posEnd+1);
                             }
 
-                            e.currentTarget.setAttribute('readonly', 'readonly');
-                            setTimeout(() => {
-                                $_el.removeAttribute('readonly');
-                                setTimeout(() => {
-                                    if (posStart != posEnd) {
-                                        setCaretToPos($_el, posStart);
-                                    } else if (posStart == 0) {
-                                        setCaretToPos($_el, posStart);
-                                    } else {
-                                        setCaretToPos($_el, posStart);
-                                    }
-                                }, 0)
-
-                            }, 0);
+                            // #B389 — synchronous caret commit + guarded deferred
+                            // restore (the retired tail below re-applied a stale
+                            // per-keystroke capture two macrotasks later; its
+                            // if/else chain always resolved to posStart anyway).
+                            // e.currentTarget.setAttribute('readonly', 'readonly');
+                            // setTimeout(() => {
+                            //     $_el.removeAttribute('readonly');
+                            //     setTimeout(() => {
+                            //         if (posStart != posEnd) {
+                            //             setCaretToPos($_el, posStart);
+                            //         } else if (posStart == 0) {
+                            //             setCaretToPos($_el, posStart);
+                            //         } else {
+                            //             setCaretToPos($_el, posStart);
+                            //         }
+                            //     }, 0)
+                            //
+                            // }, 0);
+                            commitCaret($_el, posStart);
+                            queueCaretRestore($_el);
                             break
                         case 8: //Backspace
                             if (posStart != posEnd) {
@@ -16717,25 +16799,36 @@ function ValidatorPlugin(rules, data, formId, culture) {
                                     $_el.value = str.substring(posEnd);
                                 }
                             } else if (posStart == 0) {
-                                $_el.value = str.substring(posStart+1);
+                                // #B390 — native Backspace at position 0 is a
+                                // NO-OP: nothing sits before the caret. The
+                                // retired rebuild below deleted the FIRST
+                                // character instead. No value change, no caret
+                                // move, no restore to queue.
+                                // $_el.value = str.substring(posStart+1);
+                                break;
                             } else {
                                 $_el.value = str.substring(0, posStart-1) + str.substring(posEnd);
                             }
 
-                            e.currentTarget.setAttribute('readonly', 'readonly');
-                            setTimeout(() => {
-                                $_el.removeAttribute('readonly');
-                                setTimeout(() => {
-                                    if (posStart != posEnd) {
-                                        setCaretToPos($_el, posStart);
-                                    } else if (posStart == 0) {
-                                        setCaretToPos($_el, posStart);
-                                    } else {
-                                        setCaretToPos($_el, posStart-1);
-                                    }
-                                }, 0)
-
-                            }, 0);
+                            // #B389 — synchronous caret commit + guarded deferred
+                            // restore (the retired tail below re-applied a stale
+                            // per-keystroke capture two macrotasks later).
+                            // e.currentTarget.setAttribute('readonly', 'readonly');
+                            // setTimeout(() => {
+                            //     $_el.removeAttribute('readonly');
+                            //     setTimeout(() => {
+                            //         if (posStart != posEnd) {
+                            //             setCaretToPos($_el, posStart);
+                            //         } else if (posStart == 0) {
+                            //             setCaretToPos($_el, posStart);
+                            //         } else {
+                            //             setCaretToPos($_el, posStart-1);
+                            //         }
+                            //     }, 0)
+                            //
+                            // }, 0);
+                            commitCaret($_el, (posStart != posEnd) ? posStart : posStart-1);
+                            queueCaretRestore($_el);
                             break;
                         case 9: // Tab
                             if (keyboardMapping[16] && keyboardMapping[9]) {
@@ -16749,11 +16842,19 @@ function ValidatorPlugin(rules, data, formId, culture) {
                             break;
                         case 37: // ArrowLeft
                             console.debug('moving left ', posStart-1);
-                            setCaretToPos($_el, posStart-1);
+                            // #B392 — setCaretToPos(-1) at position 0 coerces to
+                            // the unsigned maximum and clamps to the END of the
+                            // field (measured on WebKit and Chromium): floor at
+                            // 0. #B389 — commit through the tracker so a pending
+                            // deferred restore cannot undo the arrow move.
+                            // setCaretToPos($_el, posStart-1);
+                            commitCaret($_el, (posStart > 0) ? posStart-1 : 0);
                             break;
                         case 39: // ArrowRight
                             if (posStart+1 < str.length+1) {
-                                setCaretToPos($_el, posStart+1);
+                                // #B389 — through the tracker (see ArrowLeft).
+                                // setCaretToPos($_el, posStart+1);
+                                commitCaret($_el, posStart+1);
                             }
                             break;
                         // Shortcuts
@@ -16827,15 +16928,24 @@ function ValidatorPlugin(rules, data, formId, culture) {
                             } else {
                                 $_el.value = str.substring(0, posStart) + e.key + str.substring(posEnd);
                             }
-                            e.currentTarget.setAttribute('readonly', 'readonly');
-                            // Force restore last caret position
-                            setTimeout(() => {
-                                $_el.removeAttribute('readonly');
-                                setTimeout(() => {
-                                    setCaretToPos($_el, posStart+1);
-                                }, 0);
-
-                            }, 0);
+                            // #B389 — synchronous caret commit + guarded deferred
+                            // restore. The retired tail below only restored the
+                            // caret two macrotasks after the `.value` assignment
+                            // (which parks it at the end of the field), so a fast
+                            // second keystroke read a stale selectionStart and
+                            // inserted at the wrong offset — text landed at the
+                            // end instead of the caret (gh issue #63).
+                            // e.currentTarget.setAttribute('readonly', 'readonly');
+                            // // Force restore last caret position
+                            // setTimeout(() => {
+                            //     $_el.removeAttribute('readonly');
+                            //     setTimeout(() => {
+                            //         setCaretToPos($_el, posStart+1);
+                            //     }, 0);
+                            //
+                            // }, 0);
+                            commitCaret($_el, posStart+1);
+                            queueCaretRestore($_el);
                             break;
                     } //EO Switch
                 });