ranger-compiler 3.0.5 → 3.1.1

package/dist/lib/IsoDate/DateMath.rgr

@@ -0,0 +1,219 @@
+
+; Portable calendar math on ISO-8601 date strings (YYYY-MM-DD).
+; No host Date, timezone, or locale — safe to compile to any Ranger target.
+
+class DateParts {
+    def year:int 2000
+    def month:int 1
+    def day:int 1
+
+    static fn fromIso:DateParts (iso:string) {
+        def p (new DateParts)
+        p.year = (DateMath.parseIsoComponent(iso 0 4))
+        p.month = (DateMath.parseIsoComponent(iso 5 2))
+        p.day = (DateMath.parseIsoComponent(iso 8 2))
+        return p
+    }
+
+    fn toIso:string () {
+        return (DateMath.formatIso(this.year this.month this.day))
+    }
+}
+
+class DateMath {
+    static fn parseIsoComponent:int (iso:string start:int len:int) {
+        def out@(mutable):int 0
+        def i@(mutable):int 0
+        while (i < len) {
+            def ch (charAt iso (start + i))
+            out = (out * 10) + (ch - 48)
+            i = i + 1
+        }
+        return out
+    }
+
+    static fn intToString:string (n:int) {
+        if (n == 0) {
+            return "0"
+        }
+        def digits:[string]
+        def v@(mutable):int n
+        while (v > 0) {
+            def digit (v % 10)
+            push digits (DateMath.digitChar(digit))
+            v = (floor ((v - digit) / 10))
+        }
+        def out:string ""
+        def cnt (array_length digits)
+        def i@(mutable):int (cnt - 1)
+        while (i >= 0) {
+            out = out + (itemAt digits i)
+            i = i - 1
+        }
+        return out
+    }
+
+    static fn digitChar:string (d:int) {
+        if (d == 0) {
+            return "0"
+        }
+        if (d == 1) {
+            return "1"
+        }
+        if (d == 2) {
+            return "2"
+        }
+        if (d == 3) {
+            return "3"
+        }
+        if (d == 4) {
+            return "4"
+        }
+        if (d == 5) {
+            return "5"
+        }
+        if (d == 6) {
+            return "6"
+        }
+        if (d == 7) {
+            return "7"
+        }
+        if (d == 8) {
+            return "8"
+        }
+        return "9"
+    }
+
+    static fn pad2:string (n:int) {
+        if (n < 10) {
+            return ("0" + (DateMath.intToString(n)))
+        }
+        return (DateMath.intToString(n))
+    }
+
+    static fn formatIso:string (year:int month:int day:int) {
+        return ((DateMath.intToString(year)) + "-" + (DateMath.pad2(month)) + "-" + (DateMath.pad2(day)))
+    }
+
+    static fn isLeapYear:boolean (year:int) {
+        if ((year % 4) != 0) {
+            return false
+        }
+        if ((year % 100) != 0) {
+            return true
+        }
+        if ((year % 400) != 0) {
+            return false
+        }
+        return true
+    }
+
+    static fn daysInMonth:int (year:int month:int) {
+        if (month == 2) {
+            if ((DateMath.isLeapYear(year))) {
+                return 29
+            }
+            return 28
+        }
+        if (month == 4) {
+            return 30
+        }
+        if (month == 6) {
+            return 30
+        }
+        if (month == 9) {
+            return 30
+        }
+        if (month == 11) {
+            return 30
+        }
+        return 31
+    }
+
+    static fn subtractOneDay:string (iso:string) {
+        def p (DateParts.fromIso(iso))
+        p.day = p.day - 1
+        if (p.day >= 1) {
+            return (p.toIso())
+        }
+        p.month = p.month - 1
+        if (p.month >= 1) {
+            p.day = (DateMath.daysInMonth(p.year p.month))
+            return (p.toIso())
+        }
+        p.month = 12
+        p.year = p.year - 1
+        p.day = (DateMath.daysInMonth(p.year p.month))
+        return (p.toIso())
+    }
+
+    static fn addDays:string (iso:string days:int) {
+        if (days == 0) {
+            def same (DateParts.fromIso(iso))
+            return (same.toIso())
+        }
+        if (days > 0) {
+            def p (DateParts.fromIso(iso))
+            def remaining@(mutable):int days
+            while (remaining > 0) {
+                p.day = p.day + 1
+                def dim (DateMath.daysInMonth(p.year p.month))
+                if (p.day > dim) {
+                    p.day = 1
+                    p.month = p.month + 1
+                    if (p.month > 12) {
+                        p.month = 1
+                        p.year = p.year + 1
+                    }
+                }
+                remaining = remaining - 1
+            }
+            return (p.toIso())
+        }
+        def remainingNeg@(mutable):int (0 - days)
+        def current:string iso
+        while (remainingNeg > 0) {
+            current = (DateMath.subtractOneDay(current))
+            remainingNeg = remainingNeg - 1
+        }
+        return current
+    }
+
+    static fn compareIso:int (a:string b:string) {
+        if (a == b) {
+            return 0
+        }
+        def pa (DateParts.fromIso(a))
+        def pb (DateParts.fromIso(b))
+        if (pa.year != pb.year) {
+            if (pa.year < pb.year) {
+                return -1
+            }
+            return 1
+        }
+        if (pa.month != pb.month) {
+            if (pa.month < pb.month) {
+                return -1
+            }
+            return 1
+        }
+        if (pa.day < pb.day) {
+            return -1
+        }
+        return 1
+    }
+
+    static fn isBetween:boolean (d:string start:string end:string) {
+        if ((DateMath.compareIso(d start)) < 0) {
+            return false
+        }
+        if ((DateMath.compareIso(d end)) > 0) {
+            return false
+        }
+        return true
+    }
+
+    static fn msPerDay:int () {
+        return 86400000
+    }
+}

package/dist/lib/IsoDate/IsoCalendar.rgr

@@ -0,0 +1,137 @@
+
+Import "DateMath.rgr"
+Import "IsoDateParse.rgr"
+
+; ISO week numbers, day-of-week, and calendar offsets (no timezone).
+class IsoCalendar {
+
+  sfn intDiv:int (numerator:int denominator:int) {
+    if (denominator <= 0) {
+      return 0
+    }
+    def num:double (int2double numerator)
+    def den:double (int2double denominator)
+    return (floor (num / den))
+  }
+
+  sfn sakamotoMonthShift:int (month:int) {
+    if (month == 1) {
+      return 0
+    }
+    if (month == 2) {
+      return 3
+    }
+    if (month == 3) {
+      return 2
+    }
+    if (month == 4) {
+      return 5
+    }
+    if (month == 5) {
+      return 0
+    }
+    if (month == 6) {
+      return 3
+    }
+    if (month == 7) {
+      return 5
+    }
+    if (month == 8) {
+      return 1
+    }
+    if (month == 9) {
+      return 4
+    }
+    if (month == 10) {
+      return 6
+    }
+    if (month == 11) {
+      return 2
+    }
+    return 4
+  }
+
+  sfn sakamotoDow:int (year:int month:int day:int) {
+    def y:int year
+    if (month < 3) {
+      y = year - 1
+    }
+    def shift:int (IsoCalendar.sakamotoMonthShift(month))
+    def y4:int (IsoCalendar.intDiv(y 4))
+    def y100:int (IsoCalendar.intDiv(y 100))
+    def y400:int (IsoCalendar.intDiv(y 400))
+    def q:int (y + y4 - y100 + y400 + shift + day)
+    def r:int (q % 7)
+    if (r < 0) {
+      r = r + 7
+    }
+    return r
+  }
+
+  sfn dayOfWeekIso:int (year:int month:int day:int) {
+    def dow:int (IsoCalendar.sakamotoDow(year month day))
+    if (dow == 0) {
+      return 7
+    }
+    return dow
+  }
+
+  sfn addDaysOffset:string (iso:string days:int) {
+    return (DateMath.addDays(iso days))
+  }
+
+  sfn daysBetween:int (fromIso:string toIso:string) {
+    def count:int 0
+    def current:string fromIso
+    while ((DateMath.compareIso(current toIso)) < 0) {
+      current = (DateMath.addDays(current 1))
+      count = count + 1
+      if (count > 4000) {
+        return 0
+      }
+    }
+    if (current == toIso) {
+      return count
+    }
+    return 0
+  }
+
+  sfn pad2:string (n:int) {
+    if (n < 10) {
+      return ("0" + (DateMath.intToString(n)))
+    }
+    return (DateMath.intToString(n))
+  }
+
+  sfn isoWeekKey:string (iso:string) {
+    def dateOnly:string (IsoDateParse.toIsoDateOnly(iso))
+    if ((strlen dateOnly) == 0) {
+      return ""
+    }
+    def week:int (IsoCalendar.getIsoWeekNumber(dateOnly))
+    if (week <= 0) {
+      return ""
+    }
+    def p:DateParts (DateParts.fromIso(dateOnly))
+    def isoDow:int (IsoCalendar.dayOfWeekIso(p.year p.month p.day))
+    def toThursday:int (4 - isoDow)
+    def thursdayIso:string (IsoCalendar.addDaysOffset(dateOnly toThursday))
+    def tp:DateParts (DateParts.fromIso(thursdayIso))
+    def isoYear:string (DateMath.intToString(tp.year))
+    return (isoYear + "-W" + (IsoCalendar.pad2(week)))
+  }
+
+  sfn getIsoWeekNumber:int (iso:string) {
+    def p:DateParts (DateParts.fromIso(iso))
+    def isoDow:int (IsoCalendar.dayOfWeekIso(p.year p.month p.day))
+    def toThursday:int (4 - isoDow)
+    def thursdayIso:string (IsoCalendar.addDaysOffset(iso toThursday))
+    def tp:DateParts (DateParts.fromIso(thursdayIso))
+    def jan4:string ((DateMath.intToString(tp.year)) + "-01-04")
+    def jan4Dow:int (IsoCalendar.dayOfWeekIso(tp.year 1 4))
+    def week1Monday:string (IsoCalendar.addDaysOffset(jan4 (1 - jan4Dow)))
+    def days:int (IsoCalendar.daysBetween(week1Monday thursdayIso))
+    def weeks:int (IsoCalendar.intDiv(days 7))
+    return (weeks + 1)
+  }
+}

package/dist/lib/IsoDate/IsoDateParse.rgr

@@ -0,0 +1,57 @@
+
+Import "DateMath.rgr"
+
+; Parse and validate ISO date strings without host locale APIs.
+class IsoDateParse {
+
+  sfn isDigit:boolean (ch:int) {
+    return (ch >= 48 && ch <= 57)
+  }
+
+  sfn toIsoDateOnly:string (value:string) {
+    if ((strlen value) < 10) {
+      return ""
+    }
+    def candidate:string (substring value 0 10)
+    if ((charAt candidate 4) != 45) {
+      return ""
+    }
+    if ((charAt candidate 7) != 45) {
+      return ""
+    }
+    def i:int 0
+    while (i < 10) {
+      if (i == 4 || i == 7) {
+        i = i + 1
+        continue
+      }
+      if ((IsoDateParse.isDigit((charAt candidate i))) == false) {
+        return ""
+      }
+      i = i + 1
+    }
+    return candidate
+  }
+
+  sfn datePartsToISO:string (year:int month:int day:int) {
+    if (year <= 0 || month <= 0 || day <= 0) {
+      return ""
+    }
+    return (DateMath.formatIso(year month day))
+  }
+
+  sfn isoDateToYear:int (iso:string) {
+    def p:DateParts (DateParts.fromIso(iso))
+    return p.year
+  }
+
+  sfn isoDateToMonth:int (iso:string) {
+    def p:DateParts (DateParts.fromIso(iso))
+    return p.month
+  }
+
+  sfn isoDateToDay:int (iso:string) {
+    def p:DateParts (DateParts.fromIso(iso))
+    return p.day
+  }
+}

package/dist/lib/IsoDateLib.rgr

@@ -0,0 +1,15 @@
+
+; Portable ISO-8601 calendar library (date-only, no timezone).
+; Convention: IsoDate = string "YYYY-MM-DD"
+;
+; Modules:
+;   IsoDate/DateMath.rgr      — addDays, compareIso, isBetween
+;   IsoDate/IsoDateParse.rgr  — toIsoDateOnly, datePartsToISO
+;   IsoDate/IsoCalendar.rgr   — ISO week, day-of-week
+;
+; Compiler intrinsics (Lang.rgr): iso_add_days, iso_compare, iso_between
+; Prefer DateMath.addDays in library code; intrinsics optimize hot paths per target.
+
+Import "IsoDate/DateMath.rgr"
+Import "IsoDate/IsoDateParse.rgr"
+Import "IsoDate/IsoCalendar.rgr"

package/dist/lib/RangerProcess.rgr

@@ -11,13 +11,28 @@ class RangerProcessBase {
   def __rangerParent:RangerProcessBase@(optional)
   def __rangerChildren:[RangerProcessBase]
 
+  ; Bump revision only (e.g. parent sync merging child pending*). Prefer over markStateDirty in sync blocks.
+  fn bumpStateGeneration:void () {
+    __rangerStateGeneration = __rangerStateGeneration + 1
+  }
+
   fn markStateDirty:void () {
     __rangerStateGeneration = __rangerStateGeneration + 1
+    this.flushUiNotify()
+  }
+
+  ; Notify host without bumping __rangerStateGeneration (after suppressUiNotify batch).
+  fn flushUiNotify:void () {
+    def uiHost:ProcessUiHost (ProcessUiHost.__singleton())
+    if (uiHost.isUiNotifySuppressed()) {
+      return
+    }
+    uiHost.notifyPathDeliveredCount = uiHost.notifyPathDeliveredCount + 1
     if ((strlen __rangerPath) > 0) {
-      ProcessUiHost.__singleton().notifyPath(__rangerPath)
+      uiHost.notifyPath(__rangerPath)
     }
     if (__rangerId != 0) {
-      ProcessUiHost.__singleton().notifyId(__rangerId)
+      uiHost.notifyId(__rangerId)
     }
   }
 
@@ -41,6 +56,21 @@ class RangerProcessBase {
     __rangerChildren = empty
   }
 
+  ; Outermost live ancestor (self if no parent). Used as dispatch-turn root.
+  fn __rangerFindRoot:RangerProcessBase () {
+    def cur:RangerProcessBase this
+    def parent@(optional):RangerProcessBase (cur.__rangerParent)
+    while ((null? parent) == false) {
+      cur = (unwrap parent)
+      parent = cur.__rangerParent
+    }
+    return cur
+  }
+
+  ; Override on app root to merge child pending* into parent before UI notify.
+  fn __rangerSyncChildren:void () {
+  }
+
   fn __rangerInvokeStart:void () {
   }
 
@@ -57,8 +87,8 @@ class RangerProcessBase {
   fn __rangerStopSubtree:void () {
   }
 
-  ; Optional inbound messaging hook; override on @process classes. proc_send calls this.
-  fn receiveMessage:void (msg:Any) {
+  ; Legacy hook; prefer typed proc_send → handler methods on @process classes.
+  fn receiveMessage:void (name:string value:string) {
   }
 }
 
@@ -123,7 +153,30 @@ class ProcessNameRegistry @singleton(true) {
 }
 
 ; Host-side UI subscriptions (React useProcess wires listeners in TS).
+; Hosts may replace notifyPath/notifyId on the singleton instance; markStateDirty respects suppressUiNotify.
 class ProcessUiHost @singleton(true) {
+  def __uiNotifySuppressDepth:int 0
+  ; Test/diagnostic: host notifyPath/notifyId deliveries (not suppressed).
+  def notifyPathDeliveredCount:int 0
+
+  fn isUiNotifySuppressed:boolean () {
+    return __uiNotifySuppressDepth > 0
+  }
+
+  fn resetNotifyDeliveryCount:void () {
+    notifyPathDeliveredCount = 0
+  }
+
+  fn beginSuppressUiNotify:void () {
+    __uiNotifySuppressDepth = __uiNotifySuppressDepth + 1
+  }
+
+  fn endSuppressUiNotify:void () {
+    if (__uiNotifySuppressDepth > 0) {
+      __uiNotifySuppressDepth = __uiNotifySuppressDepth - 1
+    }
+  }
+
   fn notifyPath:void (path:string) {
   }
 
@@ -132,6 +185,31 @@ class ProcessUiHost @singleton(true) {
 }
 
 class ProcessRuntime @singleton(true) {
+  def __dispatchTurnDepth:int 0
+
+  sfn beginDispatchTurn:void (root:RangerProcessBase) {
+    def rt:ProcessRuntime (ProcessRuntime.__singleton())
+    if (rt.__dispatchTurnDepth == 0) {
+      def uiHost:ProcessUiHost (ProcessUiHost.__singleton())
+      uiHost.beginSuppressUiNotify()
+    }
+    rt.__dispatchTurnDepth = rt.__dispatchTurnDepth + 1
+  }
+
+  sfn endDispatchTurn:void (root:RangerProcessBase) {
+    def rt:ProcessRuntime (ProcessRuntime.__singleton())
+    if (rt.__dispatchTurnDepth == 0) {
+      return
+    }
+    rt.__dispatchTurnDepth = rt.__dispatchTurnDepth - 1
+    if (rt.__dispatchTurnDepth > 0) {
+      return
+    }
+    root.__rangerSyncChildren()
+    def uiHost:ProcessUiHost (ProcessUiHost.__singleton())
+    uiHost.endSuppressUiNotify()
+    root.flushUiNotify()
+  }
 
   sfn stopInstance:void (proc:RangerProcessBase) {
     ProcessNameRegistry.__singleton().unbindIfConfigured(proc)

package/dist/lib/Regex/RegexMatch.rgr

@@ -0,0 +1,134 @@
+
+; Portable regex search: pattern and haystack are strings (no /literal/ syntax).
+; Semantics match ES6 RegExp(pattern, 'i').test(haystack) — substring search, case-insensitive.
+; Ranger-target implementation supports literals, ., *, ^, $, and \\ escapes.
+; Production targets should use the regex_test compiler intrinsic (native engines).
+
+class RegexMatch {
+
+  static fn testIgnoreCase:boolean (pattern:string haystack:string) {
+    def p (to_lowercase pattern)
+    def h (to_lowercase haystack)
+    return (RegexMatch.searchPattern(p h))
+  }
+
+  static fn searchPattern:boolean (pat:string text:string) {
+    def pLen (strlen pat)
+    def tLen (strlen text)
+    if (pLen == 0) {
+      return true
+    }
+    def startAnchored:boolean false
+    def endAnchored:boolean false
+    def coreStart:int 0
+    def coreEnd:int pLen
+    if ((charAt pat 0) == (ccode "^")) {
+      startAnchored = true
+      coreStart = 1
+    }
+    if (pLen > 0) {
+      if ((charAt pat (pLen - 1)) == (ccode "$")) {
+        endAnchored = true
+        coreEnd = pLen - 1
+      }
+    }
+    def corePat:string (substring pat coreStart (coreEnd - coreStart))
+    def cLen (strlen corePat)
+    if (cLen == 0) {
+      return true
+    }
+    if (startAnchored) {
+      return (RegexMatch.matchAt(corePat 0 text 0 endAnchored))
+    }
+    def t@(mutable):int 0
+    while (t <= tLen) {
+      if (RegexMatch.matchAt(corePat 0 text t endAnchored)) {
+        return true
+      }
+      t = t + 1
+    }
+    return false
+  }
+
+  static fn matchAt:boolean (pat:string p:int text:string t:int requireEnd:boolean) {
+    def pLen (strlen pat)
+    def tLen (strlen text)
+    if (p >= pLen) {
+      if (requireEnd) {
+        return t == tLen
+      }
+      return true
+    }
+    def ch (charAt pat p)
+    if (ch == (ccode "\\")) {
+      if ((p + 1) >= pLen) {
+        return false
+      }
+      def esc (charAt pat (p + 1))
+      def nextP:int (p + 2)
+      if (nextP < pLen) {
+        def starCh (charAt pat nextP)
+        if (starCh == (ccode "*")) {
+          return (RegexMatch.matchStar(esc false nextP pat text t requireEnd))
+        }
+      }
+      if (t >= tLen) {
+        return false
+      }
+      if ((charAt text t) != esc) {
+        return false
+      }
+      return (RegexMatch.matchAt(pat nextP text (t + 1) requireEnd))
+    }
+    if (ch == (ccode ".")) {
+      def dotNext:int (p + 1)
+      if (dotNext < pLen) {
+        def starCh2 (charAt pat dotNext)
+        if (starCh2 == (ccode "*")) {
+          return (RegexMatch.matchStar((ccode ".") true dotNext pat text t requireEnd))
+        }
+      }
+      if (t >= tLen) {
+        return false
+      }
+      return (RegexMatch.matchAt(pat (p + 1) text (t + 1) requireEnd))
+    }
+    def litNext:int (p + 1)
+    if (litNext < pLen) {
+      def starCh3 (charAt pat litNext)
+      if (starCh3 == (ccode "*")) {
+        return (RegexMatch.matchStar(ch false litNext pat text t requireEnd))
+      }
+    }
+    if (t >= tLen) {
+      return false
+    }
+    if ((charAt text t) != ch) {
+      return false
+    }
+    return (RegexMatch.matchAt(pat (p + 1) text (t + 1) requireEnd))
+  }
+
+  static fn matchStar:boolean (atomChar:int isDot:boolean starPos:int pat:string text:string t:int requireEnd:boolean) {
+    def tLen (strlen text)
+    def afterStar:int (starPos + 1)
+    def cur@(mutable):int t
+    while (cur <= tLen) {
+      if (RegexMatch.matchAt(pat afterStar text cur requireEnd)) {
+        return true
+      }
+      if (cur >= tLen) {
+        break
+      }
+      if (isDot) {
+        cur = cur + 1
+      } {
+        if ((charAt text cur) != atomChar) {
+          break
+        }
+        cur = cur + 1
+      }
+    }
+    return false
+  }
+}

package/dist/lib/RegexLib.rgr

@@ -0,0 +1,10 @@
+
+; String-based regex search (pattern as string, not /literal/ syntax).
+;
+; Modules:
+;   Regex/RegexMatch.rgr — testIgnoreCase (portable subset on ranger target)
+;
+; Compiler intrinsic (Lang.rgr): regex_test(pattern, haystack)
+; Prefer regex_test in hot paths; RegexMatch.testIgnoreCase for library code on ranger target.
+
+Import "Regex/RegexMatch.rgr"

package/dist/lib/Time.rgr

@@ -1,5 +1,6 @@
 
-; Date functions
+; Legacy ES6-only host Date wrapper.
+; For portable calendar logic use lib/IsoDateLib.rgr (ISO strings, no timezone).
 ; https://cdnjs.cloudflare.com/ajax/libs/date-fns/1.29.0/date_fns.min.js
 
 systemclass SystemDate {