@fable-org/fable-library-ts 2.0.0-beta.3 → 2.0.0-beta.5

package/Reflection.ts

@@ -1,6 +1,6 @@
-import { FSharpRef, Record, Union } from "./Types.js";
-import { combineHashCodes, equalArraysWith, IEquatable, stringHash } from "./Util.js";
-import Decimal from "./Decimal.js";
+import { FSharpRef, Record, Union } from "./Types.ts";
+import { Exception, MutableArray, combineHashCodes, equalArraysWith, IEquatable, stringHash } from "./Util.ts";
+import Decimal from "./Decimal.ts";
 
 export type FieldInfo = [string, TypeInfo];
 export type PropertyInfo = FieldInfo;
@@ -9,34 +9,67 @@ export type ParameterInfo = FieldInfo;
 export type Constructor = new (...args: any[]) => any;
 
 export class CaseInfo {
+  public declaringType: TypeInfo;
+  public tag: number;
+  public name: string;
+  public fields?: FieldInfo[];
+
   constructor(
-    public declaringType: TypeInfo,
-    public tag: number,
-    public name: string,
-    public fields?: FieldInfo[]) {
+    declaringType: TypeInfo,
+    tag: number,
+    name: string,
+    fields?: FieldInfo[]
+  ) {
+    this.declaringType = declaringType;
+    this.tag = tag;
+    this.name = name;
+    this.fields = fields;
   }
 }
 
 export type EnumCase = [string, number];
 
 export class MethodInfo {
+  public name: string;
+  public parameters: ParameterInfo[];
+  public returnType: TypeInfo;
+
   constructor(
-    public name: string,
-    public parameters: ParameterInfo[],
-    public returnType: TypeInfo,
+    name: string,
+    parameters: ParameterInfo[],
+    returnType: TypeInfo,
   ) {
+    this.name = name;
+    this.parameters = parameters;
+    this.returnType = returnType;
   }
 }
 
 export class TypeInfo implements IEquatable<TypeInfo> {
+  public fullname: string;
+  public generics?: TypeInfo[];
+  public construct?: Constructor;
+  public parent?: TypeInfo;
+  public fields?: () => FieldInfo[];
+  public cases?: () => CaseInfo[];
+  public enumCases?: EnumCase[];
+
   constructor(
-    public fullname: string,
-    public generics?: TypeInfo[],
-    public construct?: Constructor,
-    public parent?: TypeInfo,
-    public fields?: () => FieldInfo[],
-    public cases?: () => CaseInfo[],
-    public enumCases?: EnumCase[]) {
+    fullname: string,
+    generics?: TypeInfo[],
+    construct?: Constructor,
+    parent?: TypeInfo,
+    fields?: () => FieldInfo[],
+    cases?: () => CaseInfo[],
+    enumCases?: EnumCase[]
+  ) {
+    this.fullname = fullname;
+    this.generics = generics;
+    this.construct = construct;
+    this.parent = parent;
+    this.fields = fields;
+    this.cases = cases;
+    this.enumCases = enumCases;
   }
   public toString() {
     return fullName(this);
@@ -50,9 +83,9 @@ export class TypeInfo implements IEquatable<TypeInfo> {
 }
 
 export class GenericParameter extends TypeInfo {
-    constructor(name: string) {
-      super(name);
-    }
+  constructor(name: string) {
+    super(name);
+  }
 }
 
 export function getGenerics(t: TypeInfo): TypeInfo[] {
@@ -177,7 +210,7 @@ export function name(info: FieldInfo | TypeInfo | CaseInfo | MethodInfo): string
       return name(elemType) + "[]";
     } else {
       const i = info.fullname.lastIndexOf(".");
-      return i === -1 ? info.fullname : info.fullname.substr(i + 1);
+      return i === -1 ? info.fullname : info.fullname.slice(i + 1);
     }
   } else {
     return info.name;
@@ -201,7 +234,7 @@ export function namespace(t: TypeInfo): string {
     return namespace(elemType);
   } else {
     const i = t.fullname.lastIndexOf(".");
-    return i === -1 ? "" : t.fullname.substr(0, i);
+    return i === -1 ? "" : t.fullname.slice(0, i);
   }
 }
 
@@ -290,7 +323,7 @@ export function getEnumValues(t: TypeInfo): number[] {
   if (isEnum(t) && t.enumCases != null) {
     return t.enumCases.map((kv) => kv[1]);
   } else {
-    throw new Error(`${t.fullname} is not an enum type`);
+    throw new Exception(`${t.fullname} is not an enum type`);
   }
 }
 
@@ -298,7 +331,7 @@ export function getEnumNames(t: TypeInfo): string[] {
   if (isEnum(t) && t.enumCases != null) {
     return t.enumCases.map((kv) => kv[0]);
   } else {
-    throw new Error(`${t.fullname} is not an enum type`);
+    throw new Exception(`${t.fullname} is not an enum type`);
   }
 }
 
@@ -310,7 +343,7 @@ function getEnumCase(t: TypeInfo, v: number | string): EnumCase {
           return kv;
         }
       }
-      throw new Error(`'${v}' was not found in ${t.fullname}`);
+      throw new Exception(`'${v}' was not found in ${t.fullname}`);
     } else {
       for (const kv of t.enumCases) {
         if (kv[1] === v) {
@@ -321,7 +354,7 @@ function getEnumCase(t: TypeInfo, v: number | string): EnumCase {
       return ["", v];
     }
   } else {
-    throw new Error(`${t.fullname} is not an enum type`);
+    throw new Exception(`${t.fullname} is not an enum type`);
   }
 }
 
@@ -360,7 +393,7 @@ export function getUnionCases(t: TypeInfo): CaseInfo[] {
   if (t.cases != null) {
     return t.cases();
   } else {
-    throw new Error(`${t.fullname} is not an F# union type`);
+    throw new Exception(`${t.fullname} is not an F# union type`);
   }
 }
 
@@ -368,7 +401,7 @@ export function getRecordElements(t: TypeInfo): FieldInfo[] {
   if (t.fields != null) {
     return t.fields();
   } else {
-    throw new Error(`${t.fullname} is not an F# record type`);
+    throw new Exception(`${t.fullname} is not an F# record type`);
   }
 }
 
@@ -376,7 +409,7 @@ export function getTupleElements(t: TypeInfo): TypeInfo[] {
   if (isTuple(t) && t.generics != null) {
     return t.generics;
   } else {
-    throw new Error(`${t.fullname} is not a tuple type`);
+    throw new Exception(`${t.fullname} is not a tuple type`);
   }
 }
 
@@ -385,7 +418,7 @@ export function getFunctionElements(t: TypeInfo): [TypeInfo, TypeInfo] {
     const gen = t.generics;
     return [gen[0], gen[1]];
   } else {
-    throw new Error(`${t.fullname} is not an F# function type`);
+    throw new Exception(`${t.fullname} is not an F# function type`);
   }
 }
 
@@ -412,7 +445,7 @@ export function getUnionFields(v: any, t: TypeInfo): [CaseInfo, any[]] {
   const cases = getUnionCases(t);
   const case_ = cases[v.tag];
   if (case_ == null) {
-    throw new Error(`Cannot find case ${v.name} in union type`);
+    throw new Exception(`Cannot find case ${v.name} in union type`);
   }
   return [case_, v.fields];
 }
@@ -424,7 +457,7 @@ export function getUnionCaseFields(uci: CaseInfo): FieldInfo[] {
 // This is used as replacement of `FSharpValue.GetRecordFields`
 // For `FSharpTypes.GetRecordFields` see `getRecordElements`
 // Object.keys returns keys in the order they were added to the object
-export function getRecordFields(v: any): any[] {
+export function getRecordFields(v: any): MutableArray<any> {
   return Object.keys(v).map((k) => v[k]);
 }
 
@@ -432,7 +465,7 @@ export function getRecordField(v: any, field: FieldInfo): any {
   return v[field[0]];
 }
 
-export function getTupleFields(v: any): any[] {
+export function getTupleFields(v: any): MutableArray<any> {
   return v;
 }
 
@@ -440,10 +473,10 @@ export function getTupleField(v: any, i: number): any {
   return v[i];
 }
 
-export function makeUnion(uci: CaseInfo, values: any[]): any {
+export function makeUnion(uci: CaseInfo, values: MutableArray<any>): any {
   const expectedLength = (uci.fields || []).length;
   if (values.length !== expectedLength) {
-    throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);
+    throw new Exception(`Expected an array of length ${expectedLength} but got ${values.length}`);
   }
   const construct = uci.declaringType.construct;
   if (construct == null) {
@@ -458,10 +491,10 @@ export function makeUnion(uci: CaseInfo, values: any[]): any {
   }
 }
 
-export function makeRecord(t: TypeInfo, values: any[]): any {
+export function makeRecord(t: TypeInfo, values: MutableArray<any>): any {
   const fields = getRecordElements(t);
   if (fields.length !== values.length) {
-    throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);
+    throw new Exception(`Expected an array of length ${fields.length} but got ${values.length}`);
   }
   return t.construct != null
     ? new t.construct(...values)
@@ -471,7 +504,7 @@ export function makeRecord(t: TypeInfo, values: any[]): any {
     }, {} as any);
 }
 
-export function makeTuple(values: any[], _t: TypeInfo): any {
+export function makeTuple(values: MutableArray<any>, _t: TypeInfo): any {
   return values;
 }
 
@@ -506,7 +539,7 @@ export function createInstance(t: TypeInfo, consArgs?: any[]): any {
         // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null
         return null;
       default:
-        throw new Error(`Cannot access constructor of ${t.fullname}`);
+        throw new Exception(`Cannot access constructor of ${t.fullname}`);
     }
   }
 }
@@ -519,7 +552,7 @@ export function getValue(propertyInfo: PropertyInfo, v: any): any {
 
 function assertUnion(x: any) {
   if (!(x instanceof Union)) {
-    throw new Error(`Value is not an F# union type`);
+    throw new Exception(`Value is not an F# union type`);
   }
 }
 

package/RegExp.ts

@@ -1,3 +1,5 @@
+import { Exception } from "./Util.ts";
+
 export type MatchEvaluator = (match: any) => string;
 
 export function create(pattern: string, options = 0) {
@@ -8,7 +10,7 @@ export function create(pattern: string, options = 0) {
   // * Singleline:  0x0010
   // * ECMAScript:  0x0100 (ignored)
   if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
-    throw new Error("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+    throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
   }
   // Set always global and unicode flags for compatibility with dotnet, see #2925
   let flags = "gu";
@@ -39,10 +41,10 @@ export function match(reg: RegExp, input: string, startAt = 0) {
 
 export function matches(reg: RegExp, input: string, startAt = 0) {
   if (input == null) {
-    throw new Error("Input cannot ve null");
+    throw new Exception("Input cannot ve null");
   }
   if (!reg.global) {
-    throw new Error("Non-global RegExp"); // Prevent infinite loop
+    throw new Exception("Non-global RegExp"); // Prevent infinite loop
   }
   reg.lastIndex = startAt;
   const matches: RegExpExecArray[] = [];