iam-floyd 0.848.0 → 0.849.0

package/dotnet/src/IAM.Floyd/Js.cs

@@ -0,0 +1,272 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace IAM.Floyd;
+
+/// <summary>
+/// The semantics of JavaScript that the transpiled code relies on.
+/// </summary>
+internal static class Js
+{
+    /// <summary>
+    /// Whether a value is a number.
+    /// </summary>
+    public static bool IsNumber(object value)
+    {
+        return value is double || value is int || value is long || value is float
+            || value is short || value is byte || value is decimal;
+    }
+
+    /// <summary>
+    /// Array.isArray: whether a value is a sequence, other than a string or a dictionary.
+    /// </summary>
+    public static bool IsArray(object value)
+    {
+        return value is IEnumerable && !(value is string) && !(value is IDictionary);
+    }
+
+    /// <summary>
+    /// A sequence as list.
+    /// </summary>
+    public static List<object> ToList(object value)
+    {
+        var result = new List<object>();
+        foreach (var item in (IEnumerable)value)
+        {
+            result.Add(item);
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// The result of the typeof operator of JavaScript.
+    /// </summary>
+    public static string Typeof(object value)
+    {
+        if (value == null)
+        {
+            return "undefined";
+        }
+        if (value is bool)
+        {
+            return "boolean";
+        }
+        if (IsNumber(value))
+        {
+            return "number";
+        }
+        if (value is string)
+        {
+            return "string";
+        }
+        return "object";
+    }
+
+    /// <summary>
+    /// A value as JavaScript converts it to a string.
+    /// </summary>
+    public static string ToString(object value)
+    {
+        switch (value)
+        {
+            case null:
+                return "undefined";
+            case string text:
+                return text;
+            case bool flag:
+                return flag ? "true" : "false";
+            case double number:
+                return Number(number);
+            case float number:
+                return Number(number);
+            case decimal number:
+                return Number((double)number);
+            case IFormattable formattable when IsNumber(value):
+                return formattable.ToString(null, CultureInfo.InvariantCulture);
+            case IEnumerable items when !(value is IDictionary):
+                var result = new StringBuilder();
+                var first = true;
+                foreach (var item in items)
+                {
+                    if (!first)
+                    {
+                        result.Append(',');
+                    }
+                    first = false;
+                    if (item != null)
+                    {
+                        result.Append(ToString(item));
+                    }
+                }
+                return result.ToString();
+        }
+        return value.ToString();
+    }
+
+    /// <summary>
+    /// A number as JavaScript formats it: the shortest digits that round-trip.
+    /// </summary>
+    public static string Number(double value)
+    {
+        if (double.IsNaN(value))
+        {
+            return "NaN";
+        }
+        if (double.IsInfinity(value))
+        {
+            return value > 0 ? "Infinity" : "-Infinity";
+        }
+        if (value == 0)
+        {
+            return "0";
+        }
+        if (value < 0)
+        {
+            return "-" + Number(-value);
+        }
+        // the shortest representation that parses back to the same value, e.g. 1.5E-07
+        var shortest = value.ToString("R", CultureInfo.InvariantCulture);
+        var e = shortest.IndexOf('E');
+        var mantissa = e < 0 ? shortest : shortest.Substring(0, e);
+        var exponent = e < 0 ? 0 : int.Parse(shortest.Substring(e + 1), CultureInfo.InvariantCulture);
+        var point = mantissa.IndexOf('.');
+        var digits = point < 0 ? mantissa : mantissa.Remove(point, 1);
+        // n is the position of the decimal point relative to the first digit
+        var n = (point < 0 ? mantissa.Length : point) + exponent;
+        while (digits.Length > 1 && digits[0] == '0')
+        {
+            digits = digits.Substring(1);
+            n--;
+        }
+        // trailing zeros are not significant
+        while (digits.Length > 1 && digits[digits.Length - 1] == '0')
+        {
+            digits = digits.Substring(0, digits.Length - 1);
+        }
+        var k = digits.Length;
+        var result = new StringBuilder();
+        if (k <= n && n <= 21)
+        {
+            result.Append(digits).Append('0', n - k);
+        }
+        else if (0 < n && n <= 21)
+        {
+            result.Append(digits, 0, n).Append('.').Append(digits.Substring(n));
+        }
+        else if (-6 < n && n <= 0)
+        {
+            result.Append("0.").Append('0', -n).Append(digits);
+        }
+        else
+        {
+            result.Append(digits[0]);
+            if (k > 1)
+            {
+                result.Append('.').Append(digits.Substring(1));
+            }
+            result.Append('e').Append(n - 1 >= 0 ? "+" : "-")
+                .Append(Math.Abs(n - 1).ToString(CultureInfo.InvariantCulture));
+        }
+        return result.ToString();
+    }
+
+    /// <summary>
+    /// String.prototype.substring: the indexes are clamped, and swapped if start is after end.
+    /// </summary>
+    public static string Substring(string value, int start)
+    {
+        return Substring(value, start, value.Length);
+    }
+
+    /// <summary>
+    /// String.prototype.substring: the indexes are clamped, and swapped if start is after end.
+    /// </summary>
+    public static string Substring(string value, int start, int end)
+    {
+        start = Math.Max(0, Math.Min(start, value.Length));
+        end = Math.Max(0, Math.Min(end, value.Length));
+        return start <= end
+            ? value.Substring(start, end - start)
+            : value.Substring(end, start - end);
+    }
+
+    /// <summary>
+    /// Array.prototype.filter.
+    /// </summary>
+    public static List<T> Filter<T>(List<T> list, Func<T, int, bool> predicate)
+    {
+        var result = new List<T>();
+        for (var i = 0; i < list.Count; i++)
+        {
+            if (predicate(list[i], i))
+            {
+                result.Add(list[i]);
+            }
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Array.prototype.map.
+    /// </summary>
+    public static List<TResult> Map<T, TResult>(List<T> list, Func<T, int, TResult> fn)
+    {
+        var result = new List<TResult>();
+        for (var i = 0; i < list.Count; i++)
+        {
+            result.Add(fn(list[i], i));
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Array.prototype.sort without compare function: sorts strings by UTF-16 code units.
+    /// </summary>
+    public static List<string> Sort(List<string> list)
+    {
+        list.Sort(string.CompareOrdinal);
+        return list;
+    }
+
+    /// <summary>
+    /// Date.prototype.toISOString. Dates of an unspecified kind are in UTC.
+    /// </summary>
+    public static string ToISOString(DateTime value)
+    {
+        if (value.Kind == DateTimeKind.Local)
+        {
+            value = value.ToUniversalTime();
+        }
+        return value.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'", CultureInfo.InvariantCulture);
+    }
+
+    /// <summary>
+    /// A regular expression like new RegExp(pattern, flags), with the flags i, m and s.
+    /// </summary>
+    public static Regex RegExp(string pattern, string flags)
+    {
+        var options = RegexOptions.None;
+        foreach (var flag in flags)
+        {
+            switch (flag)
+            {
+                case 'i':
+                    options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
+                    break;
+                case 'm':
+                    options |= RegexOptions.Multiline;
+                    break;
+                case 's':
+                    options |= RegexOptions.Singleline;
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported regular expression flag: " + flag);
+            }
+        }
+        return new Regex(pattern, options);
+    }
+}

package/dotnet/src/IAM.Floyd/Json.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections;
+using System.Globalization;
+using System.Reflection;
+using System.Text;
+
+namespace IAM.Floyd;
+
+/// <summary>
+/// Serializes statements and their parts to JSON, as <c>JSON.stringify</c> of JavaScript.
+/// </summary>
+public static class Json
+{
+    /// <summary>
+    /// The JSON of a value: dictionaries in the order of their keys, sequences, strings, numbers,
+    /// booleans, null, dates as ISO strings, and objects with a public <c>ToJSON()</c> method, such
+    /// as statements.
+    /// </summary>
+    /// <param name="value">The value</param>
+    /// <returns>The JSON, without whitespace</returns>
+    public static string Stringify(object value)
+    {
+        var result = new StringBuilder();
+        Write(result, value);
+        return result.ToString();
+    }
+
+    private static void Write(StringBuilder result, object value)
+    {
+        switch (value)
+        {
+            case null:
+                result.Append("null");
+                break;
+            case string text:
+                WriteString(result, text);
+                break;
+            case bool flag:
+                result.Append(flag ? "true" : "false");
+                break;
+            case double or float or decimal:
+                var number = Convert.ToDouble(value, CultureInfo.InvariantCulture);
+                result.Append(double.IsNaN(number) || double.IsInfinity(number) ? "null" : Js.Number(number));
+                break;
+            case IFormattable formattable when Js.IsNumber(value):
+                result.Append(formattable.ToString(null, CultureInfo.InvariantCulture));
+                break;
+            case DateTime date:
+                WriteString(result, Js.ToISOString(date));
+                break;
+            case IDictionary dictionary:
+                result.Append('{');
+                var first = true;
+                foreach (DictionaryEntry entry in dictionary)
+                {
+                    if (!first)
+                    {
+                        result.Append(',');
+                    }
+                    first = false;
+                    WriteString(result, Convert.ToString(entry.Key, CultureInfo.InvariantCulture));
+                    result.Append(':');
+                    Write(result, entry.Value);
+                }
+                result.Append('}');
+                break;
+            case IEnumerable items:
+                result.Append('[');
+                var firstItem = true;
+                foreach (var item in items)
+                {
+                    if (!firstItem)
+                    {
+                        result.Append(',');
+                    }
+                    firstItem = false;
+                    Write(result, item);
+                }
+                result.Append(']');
+                break;
+            default:
+                Write(result, ToJson(value));
+                break;
+        }
+    }
+
+    private static object ToJson(object value)
+    {
+        var method = value.GetType().GetMethod("ToJSON", Type.EmptyTypes);
+        if (method == null)
+        {
+            throw new ArgumentException("Cannot serialize " + value.GetType().FullName + " to JSON");
+        }
+        try
+        {
+            return method.Invoke(value, null);
+        }
+        catch (TargetInvocationException e) when (e.InnerException != null)
+        {
+            System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(e.InnerException).Throw();
+            throw;
+        }
+    }
+
+    private static void WriteString(StringBuilder result, string value)
+    {
+        result.Append('"');
+        for (var i = 0; i < value.Length; i++)
+        {
+            var c = value[i];
+            switch (c)
+            {
+                case '"':
+                    result.Append("\\\"");
+                    break;
+                case '\\':
+                    result.Append("\\\\");
+                    break;
+                case '\b':
+                    result.Append("\\b");
+                    break;
+                case '\f':
+                    result.Append("\\f");
+                    break;
+                case '\n':
+                    result.Append("\\n");
+                    break;
+                case '\r':
+                    result.Append("\\r");
+                    break;
+                case '\t':
+                    result.Append("\\t");
+                    break;
+                default:
+                    var loneSurrogate = char.IsHighSurrogate(c)
+                        ? i + 1 >= value.Length || !char.IsLowSurrogate(value[i + 1])
+                        : char.IsLowSurrogate(c) && (i == 0 || !char.IsHighSurrogate(value[i - 1]));
+                    if (c < 0x20 || loneSurrogate)
+                    {
+                        result.Append("\\u").Append(((int)c).ToString("x4", CultureInfo.InvariantCulture));
+                    }
+                    else
+                    {
+                        result.Append(c);
+                    }
+                    break;
+            }
+        }
+        result.Append('"');
+    }
+}

package/eslint.config.mjs

@@ -32,6 +32,7 @@ export default defineConfig(
       'tooter/**/*.js',
       'lib/generated/',
       'dist/',
+      'java/target/',
       'docs/build/',
     ],
   },

package/go/iamfloyd/go.mod

@@ -0,0 +1,3 @@
+module udondan.github.io/iam-floyd/go/iamfloyd
+
+go 1.21

package/go/iamfloyd/helpers.go

@@ -0,0 +1,25 @@
+package iamfloyd
+
+// String returns a pointer to a string, for the parameters of the API
+func String(value string) *string {
+	return &value
+}
+
+// Strings returns a pointer to a list of pointers to strings, for the parameters of the API
+func Strings(values ...string) *[]*string {
+	list := make([]*string, len(values))
+	for i := range values {
+		list[i] = &values[i]
+	}
+	return &list
+}
+
+// Number returns a pointer to a number, for the parameters of the API
+func Number(value float64) *float64 {
+	return &value
+}
+
+// Bool returns a pointer to a boolean, for the parameters of the API
+func Bool(value bool) *bool {
+	return &value
+}

package/go/iamfloyd/internal/js/collections.go

@@ -0,0 +1,219 @@
+package js
+
+import (
+	"sort"
+	"strconv"
+)
+
+// Entry is an entry of a Record or a Map
+type Entry[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// Record is an object of JavaScript used as dictionary: the keys that are array indexes come
+// first in ascending order, then the other keys in the order they were added.
+type Record[V any] struct {
+	keys   []string
+	values map[string]V
+}
+
+// NewRecord returns an empty record
+func NewRecord[V any]() *Record[V] {
+	return &Record[V]{values: map[string]V{}}
+}
+
+// RecordOf returns a record with the given entries
+func RecordOf[V any](entries ...Entry[string, V]) *Record[V] {
+	record := NewRecord[V]()
+	for _, entry := range entries {
+		record.Set(entry.Key, entry.Value)
+	}
+	return record
+}
+
+// Get returns the value of a key, or the zero value if the key is missing
+func (r *Record[V]) Get(key string) V {
+	return r.values[key]
+}
+
+// GetOr returns the value of a key, or the fallback if the key is missing
+func (r *Record[V]) GetOr(key string, fallback V) V {
+	if value, ok := r.values[key]; ok {
+		return value
+	}
+	return fallback
+}
+
+// Set adds or replaces the value of a key
+func (r *Record[V]) Set(key string, value V) {
+	if _, ok := r.values[key]; !ok {
+		r.keys = append(r.keys, key)
+	}
+	r.values[key] = value
+}
+
+// Has returns whether the record has a key
+func (r *Record[V]) Has(key string) bool {
+	_, ok := r.values[key]
+	return ok
+}
+
+// Len returns the number of keys
+func (r *Record[V]) Len() int {
+	return len(r.keys)
+}
+
+func arrayIndex(key string) (uint64, bool) {
+	if key == "" || (len(key) > 1 && key[0] == '0') {
+		return 0, false
+	}
+	index, err := strconv.ParseUint(key, 10, 32)
+	return index, err == nil && index < 4294967295
+}
+
+// Keys returns the keys in the order of JavaScript
+func (r *Record[V]) Keys() []string {
+	var indexes []string
+	var others []string
+	for _, key := range r.keys {
+		if _, ok := arrayIndex(key); ok {
+			indexes = append(indexes, key)
+		} else {
+			others = append(others, key)
+		}
+	}
+	if len(indexes) == 0 {
+		return others
+	}
+	sort.Slice(indexes, func(i, j int) bool {
+		a, _ := arrayIndex(indexes[i])
+		b, _ := arrayIndex(indexes[j])
+		return a < b
+	})
+	return append(indexes, others...)
+}
+
+// Values returns the values in the order of the keys
+func (r *Record[V]) Values() []V {
+	keys := r.Keys()
+	values := make([]V, len(keys))
+	for i, key := range keys {
+		values[i] = r.values[key]
+	}
+	return values
+}
+
+// Entries returns the entries in the order of the keys
+func (r *Record[V]) Entries() []Entry[string, V] {
+	keys := r.Keys()
+	entries := make([]Entry[string, V], len(keys))
+	for i, key := range keys {
+		entries[i] = Entry[string, V]{key, r.values[key]}
+	}
+	return entries
+}
+
+// MarshalJSON writes the record like JSON.stringify
+func (r *Record[V]) MarshalJSON() ([]byte, error) {
+	return []byte(Stringify(r)), nil
+}
+
+func (r *Record[V]) writeJSON(writer *jsonWriter) {
+	writer.out.WriteByte('{')
+	for i, key := range r.Keys() {
+		if i > 0 {
+			writer.out.WriteByte(',')
+		}
+		writer.writeString(key)
+		writer.out.WriteByte(':')
+		writer.write(r.values[key])
+	}
+	writer.out.WriteByte('}')
+}
+
+// Map is a Map of JavaScript: the keys are in the order they were added
+type Map[K comparable, V any] struct {
+	keys   []K
+	values map[K]V
+}
+
+// NewMap returns an empty map
+func NewMap[K comparable, V any]() *Map[K, V] {
+	return &Map[K, V]{values: map[K]V{}}
+}
+
+// Get returns the value of a key, or the zero value if the key is missing
+func (m *Map[K, V]) Get(key K) V {
+	return m.values[key]
+}
+
+// GetOr returns the value of a key, or the fallback if the key is missing
+func (m *Map[K, V]) GetOr(key K, fallback V) V {
+	if value, ok := m.values[key]; ok {
+		return value
+	}
+	return fallback
+}
+
+// Set adds or replaces the value of a key
+func (m *Map[K, V]) Set(key K, value V) {
+	if _, ok := m.values[key]; !ok {
+		m.keys = append(m.keys, key)
+	}
+	m.values[key] = value
+}
+
+// Has returns whether the map has a key
+func (m *Map[K, V]) Has(key K) bool {
+	_, ok := m.values[key]
+	return ok
+}
+
+// Len returns the number of keys
+func (m *Map[K, V]) Len() int {
+	return len(m.keys)
+}
+
+// Entries returns the entries in the order they were added
+func (m *Map[K, V]) Entries() []Entry[K, V] {
+	entries := make([]Entry[K, V], len(m.keys))
+	for i, key := range m.keys {
+		entries[i] = Entry[K, V]{key, m.values[key]}
+	}
+	return entries
+}
+
+// Set is a Set of JavaScript: the values are in the order they were added
+type Set[T comparable] struct {
+	values []T
+	index  map[T]bool
+}
+
+// NewSet returns an empty set
+func NewSet[T comparable]() *Set[T] {
+	return &Set[T]{index: map[T]bool{}}
+}
+
+// Add adds a value, unless the set has it
+func (s *Set[T]) Add(value T) {
+	if !s.index[value] {
+		s.index[value] = true
+		s.values = append(s.values, value)
+	}
+}
+
+// Has returns whether the set has a value
+func (s *Set[T]) Has(value T) bool {
+	return s.index[value]
+}
+
+// Len returns the number of values
+func (s *Set[T]) Len() int {
+	return len(s.values)
+}
+
+// Values returns the values in the order they were added
+func (s *Set[T]) Values() []T {
+	return append([]T(nil), s.values...)
+}