@tsonic/js 10.0.40 → 10.0.42

package/__internal/extensions/index.d.ts

@@ -0,0 +1,81 @@
+// Generated by tsbindgen - Extension Method Tables
+// This file contains method-table interfaces for C# extension methods.
+// Tables are scoped by declaring namespace (C# using semantics).
+// For each namespace with extension methods, this file exports an ExtensionMethods_<Namespace> helper.
+
+// Import namespace modules for cross-namespace type references
+import * as System from "@tsonic/dotnet/System/internal/index.js";
+import * as System_Collections_Generic from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+
+// Import primitive type aliases
+import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
+
+// Import sticky extension scope helper
+import type { Rewrap } from '@tsonic/core/lang.js';
+
+// Import CLR type aliases for generic type arguments
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+
+// Import unsafe type markers
+import type { ptr } from '@tsonic/core/types.js';
+
+// Internal helper types for sticky extension scopes
+type __TsonicExtMapOf<T> = T extends { __tsonic_ext?: infer M } ? M : {};
+type __TsonicMergeExtMaps<A, B> = A & B;
+type __TsonicWithExt<TShape, K extends string, TApplier> = { __tsonic_ext?: __TsonicMergeExtMaps<__TsonicExtMapOf<TShape>, { [P in K]: TApplier }> };
+
+// Extension method table for namespace: Tsonic.JSRuntime
+interface __TsonicExtMethods_Tsonic_JSRuntime {
+  at(this: string, index: int): Rewrap<this, string>;
+  charAt(this: string, index: int): Rewrap<this, string>;
+  charCodeAt(this: string, index: int): Rewrap<this, int>;
+  codePointAt(this: string, index: int): Rewrap<this, int>;
+  concat(this: string, ...strings: string[]): Rewrap<this, string>;
+  endsWith(this: string, searchString: string): Rewrap<this, boolean>;
+  includes(this: string, searchString: string): Rewrap<this, boolean>;
+  indexOf(this: string, searchString: string, position?: int): Rewrap<this, int>;
+  isWellFormed(this: string): Rewrap<this, boolean>;
+  lastIndexOf(this: string, searchString: string, position?: System.Nullable_1<System_Internal.Int32>): Rewrap<this, int>;
+  length(this: string): Rewrap<this, int>;
+  localeCompare(this: string, compareString: string): Rewrap<this, int>;
+  match(this: string, pattern: string): Rewrap<this, System_Collections_Generic.List_1<System_Internal.String> | undefined>;
+  matchAll(this: string, pattern: string): Rewrap<this, System_Collections_Generic.List_1<System_Collections_Generic.List_1<System_Internal.String>>>;
+  normalize(this: string, form?: string): Rewrap<this, string>;
+  padEnd(this: string, targetLength: int, padString?: string): Rewrap<this, string>;
+  padStart(this: string, targetLength: int, padString?: string): Rewrap<this, string>;
+  repeat(this: string, count: int): Rewrap<this, string>;
+  replace(this: string, search: string, replacement: string): Rewrap<this, string>;
+  replaceAll(this: string, search: string, replacement: string): Rewrap<this, string>;
+  search(this: string, pattern: string): Rewrap<this, int>;
+  slice(this: string, start: int, end?: System.Nullable_1<System_Internal.Int32>): Rewrap<this, string>;
+  split(this: string, separator: string, limit?: System.Nullable_1<System_Internal.Int32>): Rewrap<this, System_Collections_Generic.List_1<System_Internal.String>>;
+  startsWith(this: string, searchString: string): Rewrap<this, boolean>;
+  substr(this: string, start: int, length?: System.Nullable_1<System_Internal.Int32>): Rewrap<this, string>;
+  substring(this: string, start: int, end?: System.Nullable_1<System_Internal.Int32>): Rewrap<this, string>;
+  toLocaleLowerCase(this: string): Rewrap<this, string>;
+  toLocaleUpperCase(this: string): Rewrap<this, string>;
+  toLowerCase(this: string): Rewrap<this, string>;
+  toString(this: double): Rewrap<this, string>;
+  toString(this: string): Rewrap<this, string>;
+  toUpperCase(this: string): Rewrap<this, string>;
+  toWellFormed(this: string): Rewrap<this, string>;
+  trim(this: string): Rewrap<this, string>;
+  trimEnd(this: string): Rewrap<this, string>;
+  trimLeft(this: string): Rewrap<this, string>;
+  trimRight(this: string): Rewrap<this, string>;
+  trimStart(this: string): Rewrap<this, string>;
+  valueOf(this: double): Rewrap<this, double>;
+  valueOf(this: string): Rewrap<this, string>;
+}
+
+// Generic helper type for extension methods in namespace: Tsonic.JSRuntime
+interface __TsonicExtApplier_Tsonic_JSRuntime {
+  __tsonic_shape: unknown;
+  __tsonic_type: __TsonicExtMethods_Tsonic_JSRuntime;
+}
+
+export type ExtensionMethods_Tsonic_JSRuntime<TShape> =
+  TShape extends null | undefined ? TShape
+  : TShape extends void ? void
+  : TShape & __TsonicWithExt<TShape, "Tsonic.JSRuntime", __TsonicExtApplier_Tsonic_JSRuntime> & __TsonicExtMethods_Tsonic_JSRuntime;
+

package/bindings.json

@@ -8,27 +8,32 @@
     "Date": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
-      "type": "Tsonic.JSRuntime.Date"
+      "type": "Tsonic.JSRuntime.Date",
+      "staticType": "Tsonic.JSRuntime.Date"
     },
     "JSON": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
-      "type": "Tsonic.JSRuntime.JSON"
+      "type": "Tsonic.JSRuntime.JSON",
+      "staticType": "Tsonic.JSRuntime.JSON"
     },
     "Math": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
-      "type": "Tsonic.JSRuntime.Math"
+      "type": "Tsonic.JSRuntime.Math",
+      "staticType": "Tsonic.JSRuntime.Math"
     },
     "Number": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
-      "type": "Tsonic.JSRuntime.Number"
+      "type": "Tsonic.JSRuntime.Number",
+      "staticType": "Tsonic.JSRuntime.Number"
     },
     "RegExp": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
-      "type": "Tsonic.JSRuntime.RegExp"
+      "type": "Tsonic.JSRuntime.RegExp",
+      "staticType": "Tsonic.JSRuntime.RegExp"
     },
     "Map": {
       "kind": "global",
@@ -42,10 +47,17 @@
       "type": "Tsonic.JSRuntime.Set`1",
       "csharpName": "Set"
     },
+    "Object": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Object",
+      "staticType": "Tsonic.JSRuntime.Object"
+    },
     "String": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
-      "type": "Tsonic.JSRuntime.String"
+      "type": "Tsonic.JSRuntime.String",
+      "staticType": "Tsonic.JSRuntime.String"
     },
     "Array": {
       "kind": "global",
@@ -84,6 +96,30 @@
       "type": "Tsonic.JSRuntime.Globals",
       "csharpName": "Globals.isNaN"
     },
+    "setTimeout": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Timers",
+      "csharpName": "Timers.setTimeout"
+    },
+    "clearTimeout": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Timers",
+      "csharpName": "Timers.clearTimeout"
+    },
+    "setInterval": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Timers",
+      "csharpName": "Timers.setInterval"
+    },
+    "clearInterval": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Timers",
+      "csharpName": "Timers.clearInterval"
+    },
     "RangeError": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",

package/core-globals.d.ts

@@ -26,6 +26,7 @@ declare global {
   }
 
   interface String {
+    readonly [n: number]: string;
   }
 
   interface Number {

package/globals.d.ts

@@ -1,4 +1,5 @@
-import type { int, long, double } from "@tsonic/core/types.js";
+import type { int, long } from "@tsonic/core/types.js";
+import type { Date as JSRuntimeDate } from "./index/internal/index.js";
 
 declare global {
   class RangeError extends Error {
@@ -58,24 +59,24 @@ declare global {
 
   interface Number {
     toString(): string;
-    valueOf(): double;
+    valueOf(): number;
   }
 
   interface NumberConstructor {
-    readonly EPSILON: double;
-    readonly MAX_SAFE_INTEGER: double;
-    readonly MAX_VALUE: double;
-    readonly MIN_SAFE_INTEGER: double;
-    readonly MIN_VALUE: double;
-    readonly NEGATIVE_INFINITY: double;
-    readonly POSITIVE_INFINITY: double;
-    readonly NaN: double;
-    isFinite(value: double): boolean;
-    isInteger(value: double): boolean;
-    isNaN(value: double): boolean;
-    isSafeInteger(value: double): boolean;
-    parseFloat(str: string): double;
-    parseInt(str: string, radix?: int): long | undefined;
+    readonly EPSILON: number;
+    readonly MAX_SAFE_INTEGER: number;
+    readonly MAX_VALUE: number;
+    readonly MIN_SAFE_INTEGER: number;
+    readonly MIN_VALUE: number;
+    readonly NEGATIVE_INFINITY: number;
+    readonly POSITIVE_INFINITY: number;
+    readonly NaN: number;
+    isFinite(value: number): boolean;
+    isInteger(value: number): boolean;
+    isNaN(value: number): boolean;
+    isSafeInteger(value: number): boolean;
+    parseFloat(str: string): number;
+    parseInt(str: string, radix?: number): number;
   }
 
   interface Array<T> {
@@ -231,9 +232,7 @@ declare global {
     of<T>(...items: T[]): T[];
   }
 
-  interface Date {
-    toISOString(): string;
-    getTime(): long;
+  interface Date extends JSRuntimeDate {
   }
 
   interface DateConstructor {
@@ -249,10 +248,10 @@ declare global {
   }
 
   interface Math {
-    round(x: double): double;
-    max(...values: double[]): double;
-    min(...values: double[]): double;
-    random(): double;
+    round(x: number): number;
+    max(...values: double[]): number;
+    min(...values: double[]): number;
+    random(): number;
   }
 
   interface RegExpMatchArray extends Array<string> {
@@ -275,8 +274,15 @@ declare global {
     clear(): void;
     delete(key: K): boolean;
     get(key: K): V | undefined;
+    entries(): Iterable<[K, V]>;
+    forEach(callback: (value: V) => void): void;
+    forEach(callback: (value: V, key: K) => void): void;
+    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
     has(key: K): boolean;
+    keys(): Iterable<K>;
     set(key: K, value: V): this;
+    values(): Iterable<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
   }
 
   interface MapConstructor {
@@ -288,13 +294,26 @@ declare global {
     add(value: T): this;
     clear(): void;
     delete(value: T): boolean;
+    entries(): Iterable<[T, T]>;
+    forEach(callback: (value: T) => void): void;
+    forEach(callback: (value: T, key: T) => void): void;
+    forEach(callback: (value: T, key: T, set: Set<T>) => void): void;
     has(value: T): boolean;
+    keys(): Iterable<T>;
+    values(): Iterable<T>;
+    [Symbol.iterator](): IterableIterator<T>;
   }
 
   interface SetConstructor {
     new<T = unknown>(values?: readonly T[] | null): Set<T>;
   }
 
+  interface ObjectConstructor {
+    entries(obj: unknown): [string, unknown][];
+    keys(obj: unknown): string[];
+    values(obj: unknown): unknown[];
+  }
+
   const String: StringConstructor;
 
   const Number: NumberConstructor;
@@ -313,21 +332,23 @@ declare global {
 
   const Set: SetConstructor;
 
-  function parseInt(str: string, radix?: int): long | undefined;
+  const Object: ObjectConstructor;
+
+  function parseInt(str: string, radix?: number): number;
 
-  function parseFloat(str: string): double;
+  function parseFloat(str: string): number;
 
-  function isFinite(value: double): boolean;
+  function isFinite(value: number): boolean;
 
-  function isNaN(value: double): boolean;
+  function isNaN(value: number): boolean;
 
-  function setTimeout(handler: (...args: unknown[]) => void, timeout?: int, ...args: unknown[]): int;
+  function setTimeout(handler: (...args: unknown[]) => void, timeout?: number, ...args: unknown[]): number;
 
-  function clearTimeout(id: int): void;
+  function clearTimeout(id: number): void;
 
-  function setInterval(handler: (...args: unknown[]) => void, timeout?: int, ...args: unknown[]): int;
+  function setInterval(handler: (...args: unknown[]) => void, timeout?: number, ...args: unknown[]): number;
 
-  function clearInterval(id: int): void;
+  function clearInterval(id: number): void;
 }
 
 export {};