@fable-org/fable-library-js 1.8.0 → 1.10.0

package/Array.js

@@ -4,6 +4,7 @@ import { value as value_2, map as map_1, defaultArg, some } from "./Option.js";
 import { min as min_1, max as max_1 } from "./Double.js";
 import { equals as equals_1, disposeSafe, getEnumerator, copyToArray, defaultOf } from "./Util.js";
 import { SR_indexOutOfBounds } from "./Global.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
 function indexNotFound() {
     throw new Error("An index satisfying the predicate was not found in the collection.");
 }
@@ -773,15 +774,15 @@ export function splitAt(index, array) {
     return [array.slice(0, (0 + index)), array.slice(index)];
 }
 export function compareWith(comparer, source1, source2) {
-    if (source1 == null) {
-        if (source2 == null) {
+    if (Operators_IsNull(source1)) {
+        if (Operators_IsNull(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (source2 == null) {
+    else if (Operators_IsNull(source2)) {
         return 1;
     }
     else {
@@ -809,15 +810,15 @@ export function compareWith(comparer, source1, source2) {
     }
 }
 export function compareTo(comparer, source1, source2) {
-    if (source1 == null) {
-        if (source2 == null) {
+    if (Operators_IsNull(source1)) {
+        if (Operators_IsNull(source2)) {
             return 0;
         }
         else {
             return -1;
         }
     }
-    else if (source2 == null) {
+    else if (Operators_IsNull(source2)) {
         return 1;
     }
     else {
@@ -841,15 +842,15 @@ export function compareTo(comparer, source1, source2) {
     }
 }
 export function equalsWith(equals, array1, array2) {
-    if (array1 == null) {
-        if (array2 == null) {
+    if (Operators_IsNull(array1)) {
+        if (Operators_IsNull(array2)) {
             return true;
         }
         else {
             return false;
         }
     }
-    else if (array2 == null) {
+    else if (Operators_IsNull(array2)) {
         return false;
     }
     else {
@@ -1223,7 +1224,7 @@ export function resize(xs, newSize, zero, cons) {
         throw new Error("The input must be non-negative.\\nParameter name: newSize");
     }
     const zero_1 = defaultArg(zero, defaultOf());
-    if (xs.contents == null) {
+    if (Operators_IsNull(xs.contents)) {
         xs.contents = ((array = Helpers_allocateArrayFromCons(cons, newSize), array.fill(zero_1, 0, (0 + newSize))));
     }
     else {

package/CHANGELOG.md

@@ -7,6 +7,22 @@ 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 `TimSpane` overload support coming from .NET 9 (by @MangelMaxime)
+
+### Fixed
+
+* [JS/TS] Fix `DateTimeOffset.ToLocalTime` (by @MangelMaxime)
+
 ## 1.8.0 - 2024-11-19
 
 * [JS/TS] Fix `h` in `DateTime.ToString` (@MangelMaxime)

package/DateOffset.d.ts

@@ -31,6 +31,7 @@ export declare function now(): IDateTimeOffset;
 export declare function utcNow(): IDateTimeOffset;
 export declare function toUniversalTime(date: IDateTimeOffset): Date;
 export declare function toLocalTime(date: IDateTimeOffset): Date;
+export declare function localDateTime(date: IDateTimeOffset): Date;
 export declare function timeOfDay(d: IDateTimeOffset): number;
 export declare function date(d: IDateTimeOffset): IDateTime;
 export declare function day(d: IDateTimeOffset): number;

package/DateOffset.js

@@ -141,6 +141,9 @@ export function toUniversalTime(date) {
     return DateTime(date.getTime(), 1 /* DateKind.UTC */);
 }
 export function toLocalTime(date) {
+    return DateTime(date.getTime() + offset(now()), 2 /* DateKind.Local */);
+}
+export function localDateTime(date) {
     return DateTime(date.getTime(), 2 /* DateKind.Local */);
 }
 export function timeOfDay(d) {

package/FSharp.Core.d.ts

@@ -1,5 +1,6 @@
 import { IDisposable, IEqualityComparer, IComparer } from "./Util.js";
-import { Option } from "./Option.js";
+import { Nullable, Option } from "./Option.js";
+import { FSharpChoice$2_$union } from "./Choice.js";
 import { StringBuilder } from "./System.Text.js";
 export declare const LanguagePrimitives_GenericEqualityComparer: any;
 export declare const LanguagePrimitives_GenericEqualityERComparer: any;
@@ -12,6 +13,19 @@ export declare function Operators_FailurePattern(exn: Error): Option<string>;
 export declare function Operators_NullArg<$a>(x: string): $a;
 export declare function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R;
 export declare function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b;
+export declare function Operators_IsNull<T>(value: T): boolean;
+export declare function Operators_IsNotNull<T>(value: T): boolean;
+export declare function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean;
+export declare function Operators_NonNull<T>(value: T): T;
+export declare function Operators_NonNullV<T extends any>(value: Nullable<T>): T;
+export declare function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T>;
+export declare function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T>;
+export declare function Operators_NonNullQuickPattern<T>(value: T): T;
+export declare function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T;
+export declare function Operators_WithNull<T>(value: T): T;
+export declare function Operators_WithNullV<T extends any>(value: T): T;
+export declare function Operators_NullV<T extends any>(): Nullable<T>;
+export declare function Operators_NullArgCheck<T>(argumentName: string, value: T): T;
 export declare function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a;
 export declare function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b;
 export declare function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a;

package/FSharp.Core.js

@@ -1,5 +1,7 @@
 import { disposeSafe, defaultOf, structuralHash, equals } from "./Util.js";
 import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
+import { value as value_1 } from "./Option.js";
+import { FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
 import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
 export const LanguagePrimitives_GenericEqualityComparer = {
     "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
@@ -54,6 +56,90 @@ export function Operators_Using(resource, action) {
 export function Operators_Lock(_lockObj, action) {
     return action();
 }
+export function Operators_IsNull(value) {
+    if (equals(value, defaultOf())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Operators_IsNotNull(value) {
+    if (equals(value, defaultOf())) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function Operators_IsNullV(value) {
+    return !(value != null);
+}
+export function Operators_NonNull(value) {
+    if (equals(value, defaultOf())) {
+        throw new Error();
+    }
+    else {
+        return value;
+    }
+}
+export function Operators_NonNullV(value) {
+    if (value != null) {
+        return value_1(value);
+    }
+    else {
+        throw new Error();
+    }
+}
+export function Operators_NullMatchPattern(value) {
+    if (equals(value, defaultOf())) {
+        return FSharpChoice$2_Choice1Of2(undefined);
+    }
+    else {
+        return FSharpChoice$2_Choice2Of2(value);
+    }
+}
+export function Operators_NullValueMatchPattern(value) {
+    if (value != null) {
+        return FSharpChoice$2_Choice2Of2(value_1(value));
+    }
+    else {
+        return FSharpChoice$2_Choice1Of2(undefined);
+    }
+}
+export function Operators_NonNullQuickPattern(value) {
+    if (equals(value, defaultOf())) {
+        throw new Error();
+    }
+    else {
+        return value;
+    }
+}
+export function Operators_NonNullQuickValuePattern(value) {
+    if (value != null) {
+        return value_1(value);
+    }
+    else {
+        throw new Error();
+    }
+}
+export function Operators_WithNull(value) {
+    return value;
+}
+export function Operators_WithNullV(value) {
+    return value;
+}
+export function Operators_NullV() {
+    return defaultOf();
+}
+export function Operators_NullArgCheck(argumentName, value) {
+    if (equals(value, defaultOf())) {
+        throw new Error(argumentName);
+    }
+    else {
+        return value;
+    }
+}
 export function ExtraTopLevelOperators_LazyPattern(input) {
     return input.Value;
 }

package/Random.js

@@ -1,5 +1,6 @@
 import { class_type } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32, toFloat64, compare, fromInt32, toInt64 } from "./BigInt.js";
+import { Operators_IsNull } from "./FSharp.Core.js";
 import { item, fill, setItem } from "./Array.js";
 function Native_random() {
     return Math.random();
@@ -111,7 +112,7 @@ export class Seeded {
     }
     NextBytes(buffer) {
         const this$ = this;
-        if (buffer == null) {
+        if (Operators_IsNull(buffer)) {
             throw new Error("buffer");
         }
         for (let i = 0; i <= (buffer.length - 1); i++) {

package/Seq.js

@@ -2,7 +2,7 @@ import { clear, defaultOf, equals, isDisposable, isArrayLike, toIterator, dispos
 import { toString } from "./Types.js";
 import { class_type } from "./Reflection.js";
 import { some, value as value_1 } 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 { SR_indexOutOfBounds } from "./Global.js";
@@ -297,7 +297,7 @@ export function indexNotFound() {
     throw new Error(SR_keyNotFoundAlt);
 }
 export function checkNonNull(argName, arg) {
-    if (arg == null) {
+    if (Operators_IsNull(arg)) {
         Operators_NullArg(argName);
     }
 }

package/System.Text.d.ts

@@ -13,6 +13,7 @@ export declare function StringBuilder_$ctor(): StringBuilder;
 export declare function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
 export declare function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder;
 export declare function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): StringBuilder;
+export declare function StringBuilder__Append_61B1CA(x: StringBuilder, c: string, repeatCount: int32): StringBuilder;
 export declare function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder;
 export declare function StringBuilder__Append_5E38073B(x: StringBuilder, o: float64): StringBuilder;
 export declare function StringBuilder__Append_Z1FBCCD16(x: StringBuilder, o: boolean): StringBuilder;

package/System.Text.js

@@ -1,4 +1,4 @@
-import { replace, format, substring, isNullOrEmpty, join } from "./String.js";
+import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.js";
 import { class_type } from "./Reflection.js";
 import { clear, int32ToString } from "./Util.js";
 import { toString } from "./Types.js";
@@ -41,6 +41,11 @@ export function StringBuilder__Append_244C7CD6(x, c) {
     void (x.buf.push(c));
     return x;
 }
+export function StringBuilder__Append_61B1CA(x, c, repeatCount) {
+    const s = replicate(repeatCount, c);
+    void (x.buf.push(s));
+    return x;
+}
 export function StringBuilder__Append_Z524259A4(x, o) {
     void (x.buf.push(int32ToString(o)));
     return x;

package/TimeSpan.d.ts

@@ -3,10 +3,11 @@ import { comparePrimitives } from "./Util.js";
 export type TimeSpan = number;
 export declare function create(d?: number, h?: number, m?: number, s?: number, ms?: number): number;
 export declare function fromTicks(ticks: number | bigint): number;
-export declare function fromDays(d: number): number;
-export declare function fromHours(h: number): number;
-export declare function fromMinutes(m: number): number;
-export declare function fromSeconds(s: number): number;
+export declare function fromDays(d: number, h?: number, m?: bigint, s?: bigint, ms?: bigint): number;
+export declare function fromHours(h: number, m?: bigint, s?: bigint, ms?: bigint): number;
+export declare function fromMinutes(m: number | bigint, s?: bigint, ms?: bigint): number;
+export declare function fromSeconds(s: number | bigint, ms?: bigint): number;
+export declare function fromMilliseconds(ms: number | bigint): number;
 export declare function days(ts: TimeSpan): number;
 export declare function hours(ts: TimeSpan): number;
 export declare function minutes(ts: TimeSpan): number;

package/TimeSpan.js

@@ -27,17 +27,20 @@ export function create(d = 0, h = 0, m = 0, s = 0, ms = 0) {
 export function fromTicks(ticks) {
     return Number(BigInt(ticks) / 10000n);
 }
-export function fromDays(d) {
-    return create(d, 0, 0, 0);
+export function fromDays(d, h = 0, m = 0n, s = 0n, ms = 0n) {
+    return create(d, h, Number(m), Number(s), Number(ms));
 }
-export function fromHours(h) {
-    return create(h, 0, 0);
+export function fromHours(h, m = 0n, s = 0n, ms = 0n) {
+    return create(0, h, Number(m), Number(s), Number(ms));
 }
-export function fromMinutes(m) {
-    return create(0, m, 0);
+export function fromMinutes(m, s = 0n, ms = 0n) {
+    return create(0, 0, Number(m), Number(s), Number(ms));
 }
-export function fromSeconds(s) {
-    return create(0, 0, s);
+export function fromSeconds(s, ms = 0n) {
+    return create(0, 0, 0, Number(s), Number(ms));
+}
+export function fromMilliseconds(ms) {
+    return Number(ms);
 }
 export function days(ts) {
     return signedRound(ts / 86400000);

package/package.json

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