@fable-org/fable-library-ts 2.0.0-beta.4 → 2.0.0-beta.6

package/Util.ts

@@ -1,14 +1,40 @@
 export type Nullable<T> = T | null | undefined;
 
-// Don't change, this corresponds to DateTime.Kind enum values in .NET
-export const enum DateKind {
-  Unspecified = 0,
-  UTC = 1,
-  Local = 2,
-}
+export interface MutableArray<T> extends Iterable<T> {
+  readonly length: number;
+  [index: number]: T;
+  every(predicate: (value: T, index: number, array: this) => unknown, thisArg?: any): boolean;
+  fill(value: T, start?: number, end?: number): this;
+  filter(predicate: (value: T, index: number, array: this) => unknown, thisArg?: any): this;
+  find(predicate: (value: T, index: number, array: this) => unknown, thisArg?: any): T | undefined;
+  findIndex(predicate: (value: T, index: number, array: this) => unknown, thisArg?: any): number;
+  forEach(callbackfn: (value: T, index: number, array: this) => void, thisArg?: any): void;
+  indexOf(searchElement: T, fromIndex?: number): number;
+  join(separator?: string): string;
+  lastIndexOf(searchElement: T, fromIndex?: number): number;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: this) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: this) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: this) => U, initialValue: U): U;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: this) => T): T;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: this) => T, initialValue: T): T;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: this) => U, initialValue: U): U;
+  reverse(): this;
+  slice(start?: number, end?: number): this;
+  some(predicate: (value: T, index: number, array: this) => unknown, thisArg?: any): boolean;
+  sort(compareFn?: (a: T, b: T) => number): this;
+}
+
+// Don't change, this corresponds to DateTimeKind.Kind enum values in .NET
+export const DateTimeKind = {
+  Unspecified: 0,
+  Utc: 1,
+  Local: 2,
+} as const;
+
+export type DateTimeKind = typeof DateTimeKind[keyof typeof DateTimeKind];
 
 export interface IDateTime extends Date {
-  kind?: DateKind;
+  kind?: DateTimeKind;
 }
 
 export interface IDateTimeOffset extends Date {
@@ -32,28 +58,54 @@ export interface IDisposable {
 }
 
 export interface IComparer<T> {
-  Compare(x: Nullable<T>, y: Nullable<T>): number;
+  Compare(x: T, y: T): number;
 }
 
 export interface IEqualityComparer<T> {
-  Equals(x: Nullable<T>, y: Nullable<T>): boolean;
+  Equals(x: T, y: T): boolean;
   GetHashCode(x: T): number;
 }
 
-export interface ICollection<T> extends Iterable<T> {
+export interface ICollection<T> extends IEnumerable<T> {
   readonly Count: number;
   readonly IsReadOnly: boolean;
   Add(item: T): void;
   Clear(): void;
   Contains(item: T): boolean;
-  CopyTo(array: T[], arrayIndex: number): void;
+  CopyTo(array: MutableArray<T>, arrayIndex: number): void;
   Remove(item: T): boolean;
 }
 
+// Exception is intentionally not derived from Error, for performance reasons (see #2160)
+export class Exception {
+  public message: string;
+
+  constructor(msg?: string) {
+    this.message = msg ?? "";
+  }
+}
+
+export function isException(x: any) {
+  return x instanceof Exception || x instanceof Error;
+}
+
+export function isPromise(x: any) {
+  return x instanceof Promise;
+}
+
+export function ensureErrorOrException(e: any): any {
+  // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
+  return (isException(e) || isPromise(e)) ? e : new Exception(String(e));
+}
+
 export function isArrayLike<T>(x: T | ArrayLike<T> | Iterable<T>): x is T[] {
   return Array.isArray(x) || ArrayBuffer.isView(x);
 }
 
+export function isMutableArray<T>(x: T | ArrayLike<T> | Iterable<T>): x is MutableArray<T> {
+  return Array.isArray(x) || ArrayBuffer.isView(x);
+}
+
 export function isIterable<T>(x: T | ArrayLike<T> | Iterable<T>): x is Iterable<T> {
   return x != null && typeof x === "object" && Symbol.iterator in x;
 }
@@ -110,7 +162,8 @@ export interface IEnumerable<T> extends Iterable<T> {
 }
 
 export class Enumerable<T> implements IEnumerable<T> {
-  constructor(private en: IEnumerator<T>) {}
+  private en: IEnumerator<T>;
+  constructor(en: IEnumerator<T>) { this.en = en; }
   public GetEnumerator(): IEnumerator<T> { return this.en; }
   public "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any> { return this.en; }
   [Symbol.iterator]() {
@@ -125,7 +178,8 @@ export class Enumerable<T> implements IEnumerable<T> {
 
 export class Enumerator<T> implements IEnumerator<T> {
   private current: T = defaultOf();
-  constructor(private iter: Iterator<T>) { }
+  private iter: Iterator<T>;
+  constructor(iter: Iterator<T>) { this.iter = iter; }
   public ["System.Collections.Generic.IEnumerator`1.get_Current"]() {
     return this.current;
   }
@@ -138,7 +192,7 @@ export class Enumerator<T> implements IEnumerator<T> {
     return !cur.done;
   }
   public ["System.Collections.IEnumerator.Reset"]() {
-    throw new Error("JS iterators cannot be reset");
+    throw new Exception("JS iterators cannot be reset");
   }
   public Dispose() {
     return;
@@ -230,7 +284,7 @@ export function comparerFromEqualityComparer<T>(comparer: IEqualityComparer<T>):
 
 export function assertEqual<T>(actual: T, expected: T, msg?: string): void {
   if (!equals(actual, expected)) {
-    throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
+    throw Object.assign(new Exception(msg || `Expected: ${expected} - Actual: ${actual}`), {
       actual,
       expected,
     });
@@ -239,7 +293,7 @@ export function assertEqual<T>(actual: T, expected: T, msg?: string): void {
 
 export function assertNotEqual<T>(actual: T, expected: T, msg?: string): void {
   if (equals(actual, expected)) {
-    throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
+    throw Object.assign(new Exception(msg || `Expected: ${expected} - Actual: ${actual}`), {
       actual,
       expected,
     });
@@ -286,8 +340,8 @@ export function dateOffset(date: IDateTime | IDateTimeOffset): number {
   const date1 = date as IDateTimeOffset;
   return typeof date1.offset === "number"
     ? date1.offset
-    : ((date as IDateTime).kind === DateKind.UTC
-      ? 0 : date.getTimezoneOffset() * -60000);
+    : ((date as IDateTime).kind === DateTimeKind.Utc
+      ? 0 : date.getTimezoneOffset() * -60_000);
 }
 
 export function int16ToString(i: number, radix?: number) {
@@ -462,13 +516,7 @@ export function physicalEquals<T>(x: T, y: T): boolean {
   return x === y;
 }
 
-export function nullableEquals<T>(x: Nullable<T>, y: Nullable<T>): boolean {
-  if (x == null) { return y == null; }
-  if (y == null) { return false; }
-  return equals(x, y);
-}
-
-export function equals<T>(x: T, y: T): boolean {
+export function equals<T>(x: Nullable<T>, y: Nullable<T>): boolean {
   if (x === y) {
     return true;
   } else if (x == null) {
@@ -917,7 +965,7 @@ export function curry20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
 }
 
 // More performant method to copy arrays, see #2352
-export function copyToArray<T>(source: T[], sourceIndex: number, target: T[], targetIndex: number, count: number): void {
+export function copyToArray<T>(source: MutableArray<T>, sourceIndex: number, target: MutableArray<T>, targetIndex: number, count: number): void {
   if (ArrayBuffer.isView(source) && ArrayBuffer.isView(target)) {
     (target as any).set((source as any).subarray(sourceIndex, sourceIndex + count), targetIndex);
   } else {

package/package.json

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

package/tsconfig.json

@@ -1,4 +1,5 @@
 {
+  "$schema": "https://json.schemastore.org/tsconfig",
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
 
@@ -14,6 +15,7 @@
     "target": "es2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "libReplacement": true,                           /* Enable lib replacement. */
     // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
     // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
     // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
@@ -35,7 +37,14 @@
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
     // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    "rewriteRelativeImportExtensions": true,             /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
     // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
 
     /* JavaScript Support */
@@ -44,7 +53,7 @@
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
 
     /* Emit */
-    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
@@ -60,16 +69,19 @@
     // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
     // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
     // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    "newLine": "lf",                                     /* Set the newline character for emitting files. */
     // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
     // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    "noEmitOnError": true,                               /* Disable emitting files if any type checking errors are reported. */
     // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
     // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
     // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
 
     /* Interop Constraints */
     // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    "erasableSyntaxOnly": true,                          /* Do not allow runtime constructs that are not part of ECMAScript. */
     // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
     "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
     // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
@@ -82,14 +94,15 @@
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
     // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
     // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
     // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
     // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    "noImplicitReturns": true,                           /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    "noFallthroughCasesInSwitch": true,                  /* Enable error reporting for fallthrough cases in switch statements. */
     // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
     // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
     // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */

package/SystemException.ts

@@ -1,7 +0,0 @@
-import { Exception } from "./Types.js";
-
-export class SystemException extends Exception {
-}
-
-export class TimeoutException extends SystemException {
-}