X-Git-Url: https://git.yukkurigames.com/?p=string-lerp.git;a=blobdiff_plain;f=string-lerp.js;h=8e3ef6417ab7fb846538f5bc57348516fcef9753;hp=607abc1a4592d6a7aa702818ee6afb0038d232a1;hb=203ddaf6c8bc3326257cfeeda9a01752fbc7ab5c;hpb=0c13ad2908e977aca58e5411e724881abca7228b

diff --git a/string-lerp.js b/string-lerp.js
index 607abc1..8e3ef64 100644
--- a/string-lerp.js
+++ b/string-lerp.js
@@ -120,16 +120,7 @@
 
     var GLYPH = /([\0-\u02FF\u0370-\u1DBF\u1E00-\u20CF\u2100-\uD7FF\uDC00-\uFE1F\uFE30-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF])([\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]*)/g;
 
-    function diffLerp(source, target, amount ) {
-        /** Interpolate between two strings using edit operations
-
-            This interpolation algorithm applys a partial edit of one
-            string into the other. This produces nice looking results,
-            but can take a significant amount of time and memory to
-            compute the edits. It is not recommended for strings
-            longer than a few hundred characters.
-        */
-
+    function diffLerpAstral(source, target, amount) {
         // If given strings with astral codepoints or combining
         // characters, split them into arrays of "glyphs" first,
         // do the edit on the list of "glyphs", and rejoin them.
@@ -137,24 +128,44 @@
         // This split is not perfect for all languages, but at least
         // it won't create invalid surrogate pairs or orphaned
         // combining characters.
-        //
-        // TODO: The way this is called is a hack.
-        if (source.match && (source.match(MULTI) || target.match(MULTI))) {
-            var sourceGlyphs = source.match(GLYPH) || [];
-            var targetGlyphs = target.match(GLYPH) || [];
-            return diffLerp(sourceGlyphs, targetGlyphs, amount).join("");
-        }
-
+        var sourceGlyphs = source.match(GLYPH) || [];
+        var targetGlyphs = target.match(GLYPH) || [];
+        var edits = diff(targetGlyphs, sourceGlyphs, 2, 2, 3);
         // The edit path works from the string end, forwards, because
         // that's how Levenshtein edits work. To match LTR reading
         // direction (and the behavior of fastLerp), swap the strings
         // and invert the parameter when editing.
+        var partial = edits.slice(0, Math.round((1 - amount) * edits.length));
+        return patchArray(partial, targetGlyphs).join("");
+    }
+
+    function diffLerpBasic(source, target, amount) {
         var edits = diff(target, source, 2, 2, 3);
+        // The edit path works from the string end, forwards, because
+        // that's how Levenshtein edits work. To match LTR reading
+        // direction (and the behavior of fastLerp), swap the strings
+        // and invert the parameter when editing.
         var partial = edits.slice(0, Math.round((1 - amount) * edits.length));
-        return patch(partial, target);
+        return patchString(partial, target);
+    }
+
+    function diffLerp(source, target, amount) {
+        /** Interpolate between two strings using edit operations
+
+            This interpolation algorithm applys a partial edit of one
+            string into the other. This produces nice looking results,
+            but can take a significant amount of time and memory to
+            compute the edits. It is not recommended for strings
+            longer than a few hundred characters.
+        */
+
+        if (source.match(MULTI) || target.match(MULTI))
+            return diffLerpAstral(source, target, amount);
+        else
+            return diffLerpBasic(source, target, amount);
     }
 
-    var NUMBERS = /(-?\d+(?:\.\d+)?)/g;
+    var NUMBERS = /(-?\d{1,20}(?:\.\d{1,20})?)/g;
 
     function areNumericTwins(source, target) {
         /** Check if a and b differ only in numerals */
@@ -171,10 +182,10 @@
             Numbers may have a leading "-" and a single "." to mark
             the decimal point, but something must be after the ".".
             No other floating point syntax (e.g. 1e6) is supported.
-            If both of the numbers in a pair are integers, the result
-            is clamped to an integer.
+            They are treated as fixed-point values, with the point's
+            position itself interpolating.
 
-            For example, numericLerp("0.0", "100", 0.123) === "12.3"
+            For example, numericLerp("0.0", "100".0, 0.123) === "12.3"
             because the "." in "0.0" is interpreted as a decimal
             point. But numericLerp("0.", "100.", 0.123) === "12."
             because the strings are interpreted as integers followed
@@ -184,7 +195,6 @@
             numerals gives undefined results.
         */
 
-        // TODO: Try to preserve precision of the original numbers.
         var sourceParts = source.split(NUMBERS);
         var targetParts = target.split(NUMBERS);
         var destParts = targetParts;
@@ -194,9 +204,11 @@
             var part = nlerp(+sourcePart, +targetPart, amount);
             var sourcePoint = sourcePart.indexOf(".");
             var targetPoint = targetPart.indexOf(".");
-            if (sourcePoint === -1 && targetPoint === -1)
-                part = Math.round(part);
-            targetParts[i] = part.toString();
+            var point = Math.round(nlerp(
+                sourcePoint >= 0 ? (sourcePart.length - 1) - sourcePoint : 0,
+                targetPoint >= 0 ? (targetPart.length - 1) - targetPoint : 0,
+                amount));
+            targetParts[i] = part.toFixed(point);
         }
         return targetParts.join("");
     }