capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/util/BaseAnalyzeManager.kt

@@ -0,0 +1,44 @@
+package io.github.abc15018045126.sora.lang.util
+
+import android.os.Bundle
+import androidx.annotation.CallSuper
+import io.github.abc15018045126.sora.lang.analysis.AnalyzeManager
+import io.github.abc15018045126.sora.lang.analysis.StyleReceiver
+import io.github.abc15018045126.sora.text.ContentReference
+
+/**
+ * Convenience base class for simple [AnalyzeManager] implementations
+ *
+ * @author abc15018045126
+ */
+abstract class BaseAnalyzeManager : AnalyzeManager {
+
+    override var receiver: StyleReceiver? = null
+
+    /**
+     * Get current extra arguments, maybe null
+     */
+    var extraArguments: Bundle? = null
+        private set
+
+    /**
+     * Get current content reference, maybe null
+     */
+    var contentRef: ContentReference? = null
+        private set
+
+    @CallSuper
+    override fun reset(content: ContentReference, extraArguments: Bundle) {
+        this.extraArguments = extraArguments
+        this.contentRef = content
+        rerun()
+    }
+
+    @CallSuper
+    override fun destroy() {
+        this.receiver = null
+        this.contentRef = null
+        this.extraArguments = null
+    }
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/util/PlainTextAnalyzeManager.kt

@@ -0,0 +1,30 @@
+package io.github.abc15018045126.sora.lang.util
+
+import io.github.abc15018045126.sora.lang.styling.Styles
+import io.github.abc15018045126.sora.text.CharPosition
+
+/**
+ * This class generate plain spans for content, in case when
+ * using a language without analysis you can still provide context-free completions.
+ * By default, editor does not show completions when no span is set
+ * on the text. This would be helpful for enabling completion for pure texts.
+ *
+ * @author abc15018045126
+ */
+class PlainTextAnalyzeManager : BaseAnalyzeManager() {
+
+    override fun insert(start: CharPosition, end: CharPosition, insertedContent: CharSequence) {}
+
+    override fun delete(start: CharPosition, end: CharPosition, deletedContent: CharSequence) {}
+
+    override fun rerun() {
+        val receiver = receiver
+        val ref = contentRef
+        if (receiver != null && ref != null) {
+            val style = Styles()
+            style.spans = PlainTextSpans(ref.lineCount)
+            receiver.setStyles(this, style)
+        } else receiver?.setStyles(this, null)
+    }
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/util/PlainTextSpans.kt

@@ -0,0 +1,42 @@
+package io.github.abc15018045126.sora.lang.util
+
+import io.github.abc15018045126.sora.lang.styling.EmptyReader
+import io.github.abc15018045126.sora.lang.styling.Spans
+import io.github.abc15018045126.sora.text.CharPosition
+
+/**
+ * [Spans] implementation that always returns [EmptyReader] for reading spans.
+ * Line count is automatically adjusted as content changes.
+ *
+ * @author abc15018045126
+ */
+class PlainTextSpans(private var lineCount: Int) : Spans {
+
+    fun setLineCount(lineCount: Int) {
+        this.lineCount = lineCount
+    }
+
+    override fun adjustOnInsert(start: CharPosition, end: CharPosition) {
+        lineCount += end.line - start.line
+    }
+
+    override fun adjustOnDelete(start: CharPosition, end: CharPosition) {
+        lineCount -= end.line - start.line
+    }
+
+    override fun read(): Spans.Reader {
+        return EmptyReader.INSTANCE
+    }
+
+    override fun supportsModify(): Boolean {
+        return false
+    }
+
+    override fun modify(): Spans.Modifier {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getLineCount(): Int {
+        return lineCount
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/{AndroidEmoji.java → AndroidEmoji.kt}

@@ -13,74 +13,76 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.github.abc15018045126.sora.text;
+package io.github.abc15018045126.sora.text
 
-import android.icu.lang.UCharacter;
-import android.icu.lang.UProperty;
-import android.os.Build;
-
-import androidx.annotation.RequiresApi;
+import android.icu.lang.UCharacter
+import android.icu.lang.UProperty
+import android.os.Build
+import androidx.annotation.RequiresApi
 
 /**
  * Taken from {@link android.text.Emoji}
  */
-public class AndroidEmoji {
+object AndroidEmoji {
 
-    public static int COMBINING_ENCLOSING_KEYCAP = 0x20E3;
+    const val COMBINING_ENCLOSING_KEYCAP: Int = 0x20E3
 
-    public static int ZERO_WIDTH_JOINER = 0x200D;
+    const val ZERO_WIDTH_JOINER: Int = 0x200D
 
-    public static int VARIATION_SELECTOR_16 = 0xFE0F;
+    const val VARIATION_SELECTOR_16: Int = 0xFE0F
 
-    public static int CANCEL_TAG = 0xE007F;
+    const val CANCEL_TAG: Int = 0xE007F
 
     /**
      * Returns true if the given code point is regional indicator symbol.
      */
-    public static boolean isRegionalIndicatorSymbol(int codePoint) {
-        return 0x1F1E6 <= codePoint && codePoint <= 0x1F1FF;
+    @JvmStatic
+    fun isRegionalIndicatorSymbol(codePoint: Int): Boolean {
+        return codePoint in 0x1F1E6..0x1F1FF
     }
 
     /**
      * Returns true if the given code point is emoji modifier.
      */
+    @JvmStatic
     @RequiresApi(api = Build.VERSION_CODES.P)
-    public static boolean isEmojiModifier(int codePoint) {
-        return UCharacter.hasBinaryProperty(codePoint, UProperty.EMOJI_MODIFIER);
+    fun isEmojiModifier(codePoint: Int): Boolean {
+        return UCharacter.hasBinaryProperty(codePoint, UProperty.EMOJI_MODIFIER)
     }
 
-    //
-
     /**
      * Returns true if the given code point is emoji modifier base.
      *
      * @param c codepoint to check
      * @return true if is emoji modifier base
      */
+    @JvmStatic
     @RequiresApi(api = Build.VERSION_CODES.P)
-    public static boolean isEmojiModifierBase(int c) {
+    fun isEmojiModifierBase(c: Int): Boolean {
         // These two characters were removed from Emoji_Modifier_Base in Emoji 4.0, but we need to
         // keep them as emoji modifier bases since there are fonts and user-generated text out there
         // that treats these as potential emoji bases.
         if (c == 0x1F91D || c == 0x1F93C) {
-            return true;
+            return true
         }
         // If Android's copy of ICU is behind, check for new codepoints here.
         // Consult log for implementation pattern.
-        return UCharacter.hasBinaryProperty(c, UProperty.EMOJI_MODIFIER_BASE);
+        return UCharacter.hasBinaryProperty(c, UProperty.EMOJI_MODIFIER_BASE)
     }
 
     /**
      * Returns true if the character has Emoji property.
      */
+    @JvmStatic
     @RequiresApi(api = Build.VERSION_CODES.P)
-    public static boolean isEmoji(int codePoint) {
-        return UCharacter.hasBinaryProperty(codePoint, UProperty.EMOJI);
+    fun isEmoji(codePoint: Int): Boolean {
+        return UCharacter.hasBinaryProperty(codePoint, UProperty.EMOJI)
     }
 
     // Returns true if the character can be a base character of COMBINING ENCLOSING KEYCAP.
-    public static boolean isKeycapBase(int codePoint) {
-        return ('0' <= codePoint && codePoint <= '9') || codePoint == '#' || codePoint == '*';
+    @JvmStatic
+    fun isKeycapBase(codePoint: Int): Boolean {
+        return (codePoint in '0'.code..'9'.code) || codePoint == '#'.code || codePoint == '*'.code
     }
 
     /**
@@ -88,8 +90,8 @@ public class AndroidEmoji {
      * <p>
      * Note that 0xE007F (CANCEL TAG) is not included.
      */
-    public static boolean isTagSpecChar(int codePoint) {
-        return 0xE0020 <= codePoint && codePoint <= 0xE007E;
+    @JvmStatic
+    fun isTagSpecChar(codePoint: Int): Boolean {
+        return codePoint in 0xE0020..0xE007E
     }
-
 }

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/CachedIndexer.kt

@@ -0,0 +1,408 @@
+package io.github.abc15018045126.sora.text
+
+import androidx.annotation.VisibleForTesting
+import io.github.abc15018045126.sora.annotations.UnsupportedUserUsage
+import java.util.Collections
+import kotlin.math.abs
+import kotlin.math.max
+
+/**
+ * Indexer Impl for Content with cache.
+ *
+ * Range Space of line:
+ * [0, columnCount)                            -> Text Content on Line
+ * [columnCount, columnCount + lineSepLength)  -> Line Separator for Line
+ *
+ * Merged Range: [0, columnCount + lineSepLength)
+ *
+ * Specially, the text end position is valid but not actually readable.
+ *
+ * @author Rose
+ */
+class CachedIndexer internal constructor(private val content: Content) : Indexer, ContentListener {
+    private val startPosition = CharPosition().toBOF()
+    private val endPosition = CharPosition()
+    private val cachedPositions = ArrayList<CharPosition>()
+    private val thresholdLine = 50
+    private var thresholdIndex = 50
+    var maxCacheCount = 50
+        set(maxSize) {
+            field = maxSize
+        }
+
+    init {
+        updateEnd()
+    }
+
+    /**
+     * If the querying index is larger than the switch
+     * We will add its result to cache
+     *
+     * @param s Switch
+     */
+    fun setThresholdIndex(s: Int) {
+        thresholdIndex = s
+    }
+
+    /**
+     * Update the end position
+     */
+    private fun updateEnd() {
+        endPosition.index = content.length
+        endPosition.line = content.lineCount - 1
+        endPosition.column = content.getColumnCount(endPosition.line)
+    }
+
+    /**
+     * Get the nearest cache for the given index
+     *
+     * @param index Querying index
+     * @return Nearest cache
+     */
+    @Synchronized
+    private fun findNearestByIndex(index: Int): CharPosition {
+        var minDistance = index
+        var nearestCharPosition = startPosition
+        var targetIndex = 0
+        for (i in cachedPositions.indices) {
+            val pos = cachedPositions[i]
+            val dis = abs(pos.index - index)
+            if (dis < minDistance) {
+                minDistance = dis
+                nearestCharPosition = pos
+                targetIndex = i
+            }
+            if (dis <= thresholdIndex) {
+                break
+            }
+        }
+        if (abs(endPosition.index - index) < minDistance) {
+            nearestCharPosition = endPosition
+        }
+        if (nearestCharPosition !== startPosition && nearestCharPosition !== endPosition) {
+            Collections.swap(cachedPositions, targetIndex, cachedPositions.size - 1)
+        }
+        return nearestCharPosition
+    }
+
+    /**
+     * Get the nearest cache for the given line
+     *
+     * @param line Querying line
+     * @return Nearest cache
+     */
+    @Synchronized
+    private fun findNearestByLine(line: Int): CharPosition {
+        var minDistance = line
+        var nearestCharPosition = startPosition
+        var targetIndex = 0
+        for (i in cachedPositions.indices) {
+            val pos = cachedPositions[i]
+            val dis = abs(pos.line - line)
+            if (dis < minDistance) {
+                minDistance = dis
+                nearestCharPosition = pos
+                targetIndex = i
+            }
+            if (minDistance <= thresholdLine) {
+                break
+            }
+        }
+        if (abs(endPosition.line - line) < minDistance) {
+            nearestCharPosition = endPosition
+        }
+        if (nearestCharPosition !== startPosition && nearestCharPosition !== endPosition) {
+            Collections.swap(cachedPositions, targetIndex, cachedPositions.size - 1)
+        }
+        return nearestCharPosition
+    }
+
+    /**
+     * From the given position to find forward in text
+     *
+     * @param start Given position
+     * @param index Querying index
+     */
+    @VisibleForTesting
+    fun findIndexForward(start: CharPosition, index: Int, dest: CharPosition) {
+        if (start.index > index) {
+            throw IllegalArgumentException("Unable to find backward from method findIndexForward()")
+        }
+        var workLine = start.line
+        var workColumn = start.column
+        var workIndex = start.index
+        //Move the column to the line end
+        run {
+            val addition = max(content.getLineSeparatorUnsafe(workLine).length - 1, 0)
+            val column = content.getColumnCountUnsafe(workLine) + addition
+            workIndex += column - workColumn
+            workColumn = column
+        }
+        while (workIndex < index) {
+            workLine++
+            val line = content.getLineUnsafe(workLine)
+            val addition = max(line.lineSeparatorSafe.length - 1, 0)
+            workColumn = line.length + addition
+            workIndex += workColumn + 1
+        }
+        if (workIndex > index) {
+            workColumn -= workIndex - index
+        }
+        dest.column = workColumn
+        dest.line = workLine
+        dest.index = index
+    }
+
+    /**
+     * From the given position to find backward in text
+     *
+     * @param start Given position
+     * @param index Querying index
+     */
+    @VisibleForTesting
+    fun findIndexBackward(start: CharPosition, index: Int, dest: CharPosition) {
+        if (start.index < index) {
+            throw IllegalArgumentException("Unable to find forward from method findIndexBackward()")
+        }
+        var workLine = start.line
+        var workColumn = start.column
+        var workIndex = start.index
+        while (workIndex > index) {
+            workIndex -= workColumn + 1
+            workLine--
+            if (workLine != -1) {
+                val line = content.getLineUnsafe(workLine)
+                val addition = max(line.lineSeparatorSafe.length - 1, 0)
+                workColumn = line.length + addition
+            } else {
+                // Reached the start of text,we have to use findIndexForward() as this method can not handle it
+                findIndexForward(startPosition, index, dest)
+                return
+            }
+        }
+        val dColumn = index - workIndex
+        if (dColumn > 0) {
+            workLine++
+            workColumn = dColumn - 1
+        }
+        dest.column = workColumn
+        dest.line = workLine
+        dest.index = index
+    }
+
+    /**
+     * From the given position to find forward in text
+     *
+     * @param start  Given position
+     * @param line   Querying line
+     * @param column Querying column
+     */
+    @VisibleForTesting
+    fun findLiCoForward(start: CharPosition, line: Int, column: Int, dest: CharPosition) {
+        if (start.line > line) {
+            throw IllegalArgumentException("can not find backward from findLiCoForward()")
+        }
+        var workLine = start.line
+        var workIndex = start.index
+        run {
+            //Make index to left of line
+            workIndex = workIndex - start.column
+        }
+        while (workLine < line) {
+            val lineObj = content.getLineUnsafe(workLine)
+            workIndex += lineObj.length + lineObj.lineSeparatorSafe.length
+            workLine++
+        }
+        dest.column = 0
+        dest.line = workLine
+        dest.index = workIndex
+        findInLine(dest, line, column)
+    }
+
+    /**
+     * From the given position to find backward in text
+     *
+     * @param start  Given position
+     * @param line   Querying line
+     * @param column Querying column
+     */
+    @VisibleForTesting
+    fun findLiCoBackward(start: CharPosition, line: Int, column: Int, dest: CharPosition) {
+        if (start.line < line) {
+            throw IllegalArgumentException("can not find forward from findLiCoBackward()")
+        }
+        var workLine = start.line
+        var workIndex = start.index
+        run {
+            //Make index to the left of line
+            workIndex = workIndex - start.column
+        }
+        while (workLine > line) {
+            val lineObj = content.getLineUnsafe(workLine - 1)
+            workIndex -= lineObj.length + lineObj.lineSeparatorSafe.length
+            workLine--
+        }
+        dest.column = 0
+        dest.line = workLine
+        dest.index = workIndex
+        findInLine(dest, line, column)
+    }
+
+    /**
+     * From the given position to find in this line
+     *
+     * @param pos    Given position
+     * @param line   Querying line
+     * @param column Querying column
+     */
+    private fun findInLine(pos: CharPosition, line: Int, column: Int) {
+        if (pos.line != line) {
+            throw IllegalArgumentException("can not find other lines with findInLine()")
+        }
+        pos.index = pos.index - pos.column + column
+        pos.column = column
+    }
+
+    /**
+     * Add new cache
+     *
+     * @param pos New cache
+     */
+    @Synchronized
+    private fun push(pos: CharPosition) {
+        if (maxCacheCount <= 0) {
+            return
+        }
+        cachedPositions.add(pos)
+        if (cachedPositions.size > maxCacheCount) {
+            cachedPositions.removeAt(0)
+        }
+    }
+
+    override fun getCharIndex(line: Int, column: Int): Int {
+        return getCharPosition(line, column).index
+    }
+
+    override fun getCharLine(index: Int): Int {
+        return getCharPosition(index).line
+    }
+
+    override fun getCharColumn(index: Int): Int {
+        return getCharPosition(index).column
+    }
+
+    override fun getCharPosition(index: Int): CharPosition {
+        val pos = CharPosition()
+        getCharPosition(index, pos)
+        return pos
+    }
+
+    override fun getCharPosition(index: Int, dest: CharPosition) {
+        content.checkIndex(index, Content.CHECK_TYPE_INDEX)
+        content.lock(false)
+        try {
+            val pos = findNearestByIndex(index)
+            if (pos.index == index) {
+                dest.set(pos)
+            } else if (pos.index < index) {
+                findIndexForward(pos, index, dest)
+            } else {
+                findIndexBackward(pos, index, dest)
+            }
+            if (abs(index - pos.index) >= thresholdIndex) {
+                push(dest.fromThis())
+            }
+        } finally {
+            content.unlock(false)
+        }
+    }
+
+    override fun getCharPosition(line: Int, column: Int): CharPosition {
+        val pos = CharPosition()
+        getCharPosition(line, column, pos)
+        return pos
+    }
+
+    override fun getCharPosition(line: Int, column: Int, dest: CharPosition) {
+        content.checkLineAndColumn(line, column, Content.CHECK_TYPE_INDEX)
+        content.lock(false)
+        try {
+            val pos = findNearestByLine(line)
+            if (pos.line == line) {
+                dest.set(pos)
+                if (pos.column == column) {
+                    return
+                }
+                findInLine(dest, line, column)
+            } else if (pos.line < line) {
+                findLiCoForward(pos, line, column, dest)
+            } else {
+                findLiCoBackward(pos, line, column, dest)
+            }
+            if (abs(pos.line - line) > thresholdLine) {
+                push(dest.fromThis())
+            }
+        } finally {
+            content.unlock(false)
+        }
+    }
+
+    @UnsupportedUserUsage
+    override fun beforeReplace(content: Content) {
+        //Do nothing
+    }
+
+    @Synchronized
+    @UnsupportedUserUsage
+    override fun afterInsert(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        insertedContent: CharSequence
+    ) {
+        for (pos in cachedPositions) {
+            if (pos.line == startLine) {
+                if (pos.column >= startColumn) {
+                    pos.index += insertedContent.length
+                    pos.line += endLine - startLine
+                    pos.column = endColumn + pos.column - startColumn
+                }
+            } else if (pos.line > startLine) {
+                pos.index += insertedContent.length
+                pos.line += endLine - startLine
+            }
+        }
+        updateEnd()
+    }
+
+    @Synchronized
+    @UnsupportedUserUsage
+    override fun afterDelete(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        deletedContent: CharSequence
+    ) {
+        val garbage: MutableList<CharPosition> = ArrayList()
+        for (pos in cachedPositions) {
+            if (pos.line == startLine) {
+                if (pos.column >= startColumn) garbage.add(pos)
+            } else if (pos.line > startLine) {
+                if (pos.line < endLine) {
+                    garbage.add(pos)
+                } else if (pos.line == endLine) {
+                    garbage.add(pos)
+                } else {
+                    pos.index -= deletedContent.length
+                    pos.line -= endLine - startLine
+                }
+            }
+        }
+        cachedPositions.removeAll(garbage)
+        updateEnd()
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/CharArrayWrapper.kt

@@ -0,0 +1,40 @@
+package io.github.abc15018045126.sora.text
+
+import android.text.GetChars
+import java.nio.CharBuffer
+
+/**
+ * Wrapper for char array. Make char array work as a char sequence.
+ *
+ * @author abc15018045126
+ */
+class CharArrayWrapper(
+    private val data: CharArray,
+    private val offset: Int,
+    private var count: Int
+) : CharSequence, GetChars {
+
+    constructor(array: CharArray, dataCount: Int) : this(array, 0, dataCount)
+
+    fun setDataCount(count: Int) {
+        this.count = count
+    }
+
+    override val length: Int
+        get() = count
+
+    override fun get(index: Int): Char {
+        return data[offset + index]
+    }
+
+    override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
+        return CharBuffer.wrap(data, offset + startIndex, endIndex - startIndex)
+    }
+
+    override fun getChars(start: Int, end: Int, dest: CharArray, destOffset: Int) {
+        if (end > count) {
+            throw StringIndexOutOfBoundsException()
+        }
+        System.arraycopy(data, start + this.offset, dest, destOffset, end - start)
+    }
+}