@fable-org/fable-library-ts 1.9.0 → 1.10.0

package/Array.ts

@@ -5,6 +5,7 @@ import { value as value_2, map as map_1, defaultArg, Option, some } from "./Opti
 import { min as min_1, max as max_1 } from "./Double.js";
 import { IComparer, equals as equals_1, IDisposable, disposeSafe, IEnumerator, getEnumerator, copyToArray, IEqualityComparer, defaultOf } from "./Util.js";
 import { SR_indexOutOfBounds } from "./Global.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
 import { FSharpRef } from "./Types.js";
 
 function indexNotFound<$a>(): $a {
@@ -865,15 +866,15 @@ export function splitAt<T>(index: int32, array: T[]): [T[], T[]] {
 }
 
 export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32 {
-    if (source1 == null) {
-        if (source2 == null) {
+    if (Operators_IsNull<T[]>(source1)) {
+        if (Operators_IsNull<T[]>(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (source2 == null) {
+    else if (Operators_IsNull<T[]>(source2)) {
         return 1;
     }
     else {
@@ -902,15 +903,15 @@ export function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), source1:
 }
 
 export function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T[], source2: T[]): int32 {
-    if (source1 == null) {
-        if (source2 == null) {
+    if (Operators_IsNull<T[]>(source1)) {
+        if (Operators_IsNull<T[]>(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (source2 == null) {
+    else if (Operators_IsNull<T[]>(source2)) {
         return 1;
     }
     else {
@@ -935,15 +936,15 @@ export function compareTo<T>(comparer: ((arg0: T, arg1: T) => int32), source1: T
 }
 
 export function equalsWith<T>(equals: ((arg0: T, arg1: T) => boolean), array1: T[], array2: T[]): boolean {
-    if (array1 == null) {
-        if (array2 == null) {
+    if (Operators_IsNull<T[]>(array1)) {
+        if (Operators_IsNull<T[]>(array2)) {
             return true;
         }
         else {
             return false;
         }
     }
-    else if (array2 == null) {
+    else if (Operators_IsNull<T[]>(array2)) {
         return false;
     }
     else {
@@ -1357,7 +1358,7 @@ export function resize<T>(xs: FSharpRef<T[]>, newSize: int32, zero?: Option<T>,
         throw new Error("The input must be non-negative.\\nParameter name: newSize");
     }
     const zero_1: T = defaultArg<T>(zero, defaultOf());
-    if (xs.contents == null) {
+    if (Operators_IsNull<T[]>(xs.contents)) {
         xs.contents = ((array = Helpers_allocateArrayFromCons<T>(cons, newSize), array.fill(zero_1, 0, (0 + newSize))));
     }
     else {

package/CHANGELOG.md

@@ -7,11 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 1.10.0 - 2025-01-23
+
+### Added
+
+* [JS/TS] Add `StringBuiler.Append(c: char, repeatCount: int)` overload (by @roboz0r)
+
 ## 1.9.0 - 2025-01-09
 
 ### Added
 
-* [JS/TS] Add new `TimSpan` overload support coming from .NET 9 (by @MangelMaxime)
+* [JS/TS] Add new `TimSpane` overload support coming from .NET 9 (by @MangelMaxime)
 
 ### Fixed
 

package/FSharp.Core.ts

@@ -1,7 +1,8 @@
 import { IDisposable, disposeSafe, defaultOf, IEqualityComparer, IComparer, structuralHash, equals } from "./Util.js";
 import { int32 } from "./Int32.js";
 import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
-import { Option } from "./Option.js";
+import { value as value_1, Nullable, Option } from "./Option.js";
+import { FSharpChoice$2_$union, FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
 import { StringBuilder, StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
 
 export const LanguagePrimitives_GenericEqualityComparer: any = {
@@ -68,6 +69,103 @@ export function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b {
     return action();
 }
 
+export function Operators_IsNull<T>(value: T): boolean {
+    if (equals(value, defaultOf())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+export function Operators_IsNotNull<T>(value: T): boolean {
+    if (equals(value, defaultOf())) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+
+export function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean {
+    return !(value != null);
+}
+
+export function Operators_NonNull<T>(value: T): T {
+    if (equals(value, defaultOf())) {
+        throw new Error();
+    }
+    else {
+        return value;
+    }
+}
+
+export function Operators_NonNullV<T extends any>(value: Nullable<T>): T {
+    if (value != null) {
+        return value_1(value);
+    }
+    else {
+        throw new Error();
+    }
+}
+
+export function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T> {
+    if (equals(value, defaultOf())) {
+        return FSharpChoice$2_Choice1Of2<void, T>(undefined);
+    }
+    else {
+        return FSharpChoice$2_Choice2Of2<void, T>(value);
+    }
+}
+
+export function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T> {
+    if (value != null) {
+        return FSharpChoice$2_Choice2Of2<void, T>(value_1(value));
+    }
+    else {
+        return FSharpChoice$2_Choice1Of2<void, T>(undefined);
+    }
+}
+
+export function Operators_NonNullQuickPattern<T>(value: T): T {
+    if (equals(value, defaultOf())) {
+        throw new Error();
+    }
+    else {
+        return value;
+    }
+}
+
+export function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T {
+    if (value != null) {
+        return value_1(value);
+    }
+    else {
+        throw new Error();
+    }
+}
+
+export function Operators_WithNull<T>(value: T): T {
+    return value;
+}
+
+export function Operators_WithNullV<T extends any>(value: T): T {
+    return value;
+}
+
+export function Operators_NullV<T extends any>(): Nullable<T> {
+    return defaultOf();
+}
+
+export function Operators_NullArgCheck<T>(argumentName: string, value: T): T {
+    if (equals(value, defaultOf())) {
+        throw new Error(argumentName);
+    }
+    else {
+        return value;
+    }
+}
+
 export function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a {
     return input.Value;
 }

package/Random.ts

@@ -1,6 +1,7 @@
 import { uint8, int32, float64 } from "./Int32.js";
 import { class_type, TypeInfo } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32, toFloat64, compare, int64, fromInt32, toInt64 } from "./BigInt.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
 import { item, fill, setItem } from "./Array.js";
 
 function Native_random(): float64 {
@@ -129,7 +130,7 @@ export class Seeded implements IRandom {
     }
     NextBytes(buffer: uint8[]): void {
         const this$: Seeded = this;
-        if (buffer == null) {
+        if (Operators_IsNull<uint8[]>(buffer)) {
             throw new Error("buffer");
         }
         for (let i = 0; i <= (buffer.length - 1); i++) {

package/Seq.ts

@@ -2,7 +2,7 @@ import { IComparer, clear, defaultOf, equals, isDisposable, IEqualityComparer, i
 import { toString } from "./Types.js";
 import { class_type, TypeInfo } from "./Reflection.js";
 import { some, value as value_1, Option } from "./Option.js";
-import { Operators_Lock, Operators_NullArg } from "./FSharp.Core.js";
+import { Operators_Lock, Operators_NullArg, Operators_IsNull } from "./FSharp.Core.js";
 import { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
 import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.js";
 import { int32 } from "./Int32.js";
@@ -325,7 +325,7 @@ export function indexNotFound<$a>(): $a {
 }
 
 export function checkNonNull<$a>(argName: string, arg: $a): void {
-    if (arg == null) {
+    if (Operators_IsNull<$a>(arg)) {
         Operators_NullArg<void>(argName);
     }
 }

package/System.Text.ts

@@ -1,4 +1,4 @@
-import { replace, format, substring, isNullOrEmpty, join } from "./String.js";
+import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.js";
 import { float64, int32 } from "./Int32.js";
 import { class_type, TypeInfo } from "./Reflection.js";
 import { clear, int32ToString } from "./Util.js";
@@ -53,6 +53,12 @@ export function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): Str
     return x;
 }
 
+export function StringBuilder__Append_61B1CA(x: StringBuilder, c: string, repeatCount: int32): StringBuilder {
+    const s: string = replicate(repeatCount, c);
+    void (x.buf.push(s));
+    return x;
+}
+
 export function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder {
     void (x.buf.push(int32ToString(o)));
     return x;

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "name": "@fable-org/fable-library-ts",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Core library used by F# projects compiled with fable.io",
   "author": "Fable Contributors",
   "license": "MIT",