@tsonic/js 10.0.37 → 10.0.39

package/README.md

@@ -1,33 +1,34 @@
 # @tsonic/js
 
-JavaScript-style APIs for **Tsonic**.
+JavaScript runtime bindings for **Tsonic**.
 
 This package is part of Tsonic: https://tsonic.org.
 
-Use `@tsonic/js` when you want a JS-like standard library (`console`, `JSON`, `Map`, `Set`, `Date`, timers, etc.) while still compiling to a native binary with `tsonic`.
+`@tsonic/js` provides JS runtime APIs (`JSON`, `console`, `Map`, `Set`, `Date`, timers, etc.) for Tsonic projects.
 
 ## Prerequisites
 
-- Install the .NET 10 SDK (required by Tsonic): https://dotnet.microsoft.com/download
+- Install the .NET 10 SDK: https://dotnet.microsoft.com/download
 - Verify: `dotnet --version`
 
-## Quick Start
+## Quick Start (surface-first, no `@tsonic/js` imports required)
 
 ```bash
 mkdir my-app && cd my-app
-npx --yes tsonic@latest init
+npx --yes tsonic@latest init --surface js
 npx --yes tsonic@latest add npm @tsonic/js
+```
 
-# Replace the default App.ts with a JSRuntime example
-cat > packages/my-app/src/App.ts <<'EOF'
-import { console, JSON } from "@tsonic/js/index.js";
-
+```ts
 export function main(): void {
   const value = JSON.parse<{ x: number }>('{"x": 1}');
   console.log(JSON.stringify(value));
 }
-EOF
+```
 
+Build/run:
+
+```bash
 npm run dev
 ```
 
@@ -37,81 +38,48 @@ npm run dev
 npx --yes tsonic@latest add npm @tsonic/js
 ```
 
-## Versioning
-
-This repo is versioned by runtime major:
-
-- `10` → `versions/10/` → npm: `@tsonic/js@10.x`
-
-When publishing, run: `npm publish versions/10 --access public`
+If the workspace is not already JS surface, set:
 
-## Core APIs (what you get)
-
-- `console` (JS-style console)
-- `JSON` (`parse` / `stringify`)
-- `Map`, `Set`, `WeakMap`, `WeakSet`
-- `Date`, `Math`, `RegExp`, `Number`, `String`
-- Timers via `Timers.setTimeout` / `Timers.setInterval`
-- JS-style `Array` via `JSArray<T>`
-- Common globals (e.g. `parseInt`, `parseFloat`, `encodeURI`, …)
-
-## Usage
-
-### `console` + JSON
-
-```typescript
-import { console, JSON } from "@tsonic/js/index.js";
-
-export function main(): void {
-  const value = JSON.parse<{ x: number }>('{"x": 1}');
-  console.log(JSON.stringify(value));
-}
+```bash
+npx --yes tsonic@latest init --surface js
 ```
 
-### Timers
+## Optional direct imports
 
-```typescript
-import { Timers, console } from "@tsonic/js/index.js";
+Surface mode enables natural JS authoring, but direct package imports remain supported:
 
-export function main(): void {
-  Timers.setTimeout(() => console.log("later"), 250);
-}
+```ts
+import { Timers, JSArray } from "@tsonic/js/index.js";
 ```
 
-### Collections (`Map` / `Set`)
-
-```typescript
-import { Map, Set } from "@tsonic/js/index.js";
-
-const map = new Map<string, number>();
-map.set("key", 42);
-
-const set = new Set<string>();
-set.add("value");
-```
+## Core APIs
 
-### JSArray
+- `console`
+- `JSON`
+- `Map`, `Set`, `WeakMap`, `WeakSet`
+- `Date`, `Math`, `RegExp`, `Number`, `String`
+- `Timers`
+- `JSArray<T>`
+- globals like `parseInt`, `parseFloat`, `encodeURI`
 
-```typescript
-import { JSArray } from "@tsonic/js/index.js";
+## Relationship to `@tsonic/nodejs`
 
-const arr = new JSArray<number>();
-arr.push(1, 2, 3);
-const mapped = arr.map((x) => x * 2);
-void mapped;
-```
+- `@tsonic/js` = JS runtime surface
+- `@tsonic/nodejs` = Node-style modules (`node:fs`, `node:path`, `node:crypto`, ...)
 
-## Relationship to `@tsonic/nodejs`
+## Versioning
 
-If you want Node-style modules (`fs`, `path`, `crypto`, `http`, …), use `@tsonic/nodejs`.
+- `10` → `versions/10/` → npm: `@tsonic/js@10.x`
 
-## Naming Conventions
+Publish:
 
-- `@tsonic/js` intentionally uses **JavaScript-style naming** (camelCase members).
+```bash
+npm publish versions/10 --access public
+```
 
 ## Development
 
-See `__build/` for regeneration scripts.
+See `__build/`.
 
 ## License
 

package/bindings.json

@@ -0,0 +1,77 @@
+{
+  "bindings": {
+    "console": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.console"
+    },
+    "Date": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Date"
+    },
+    "JSON": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.JSON"
+    },
+    "Math": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Math"
+    },
+    "RegExp": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.RegExp"
+    },
+    "Map": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Map`2",
+      "csharpName": "Map"
+    },
+    "Set": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Set`1",
+      "csharpName": "Set"
+    },
+    "Array": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.JSArray`1",
+      "csharpName": "JSArray"
+    },
+    "ReadonlyArray": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.JSArray`1",
+      "csharpName": "JSArray"
+    },
+    "parseInt": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Globals",
+      "csharpName": "Globals.parseInt"
+    },
+    "parseFloat": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Globals",
+      "csharpName": "Globals.parseFloat"
+    },
+    "isFinite": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Globals",
+      "csharpName": "Globals.isFinite"
+    },
+    "isNaN": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Globals",
+      "csharpName": "Globals.isNaN"
+    }
+  }
+}

package/globals.d.ts

@@ -0,0 +1,183 @@
+import type { int, long, double } from "@tsonic/core/types.js";
+
+declare global {
+  interface String {
+    readonly length: int;
+    trim(): string;
+    toUpperCase(): string;
+    toLowerCase(): string;
+    indexOf(searchString: string, position?: int): int;
+    split(separator: string, limit?: int): string[];
+    includes(searchString: string, position?: int): boolean;
+    startsWith(searchString: string, position?: int): boolean;
+    endsWith(searchString: string, endPosition?: int): boolean;
+    slice(start?: int, end?: int): string;
+    substring(start: int, end?: int): string;
+    replace(searchValue: string, replaceValue: string): string;
+    charAt(index: int): string;
+    charCodeAt(index: int): int;
+  }
+  interface Array<T> {
+    readonly length: int;
+    at(index: int): T;
+    concat(...items: T[]): T[];
+    every(callback: (value: T) => boolean): boolean;
+    filter(callback: (value: T) => boolean): T[];
+    filter(callback: (value: T, index: int) => boolean): T[];
+    find(callback: (value: T) => boolean): T | undefined;
+    find(callback: (value: T, index: int) => boolean): T | undefined;
+    findIndex(callback: (value: T) => boolean): int;
+    findIndex(callback: (value: T, index: int) => boolean): int;
+    findLast(callback: (value: T) => boolean): T | undefined;
+    findLast(callback: (value: T, index: int) => boolean): T | undefined;
+    findLastIndex(callback: (value: T) => boolean): int;
+    findLastIndex(callback: (value: T, index: int) => boolean): int;
+    flat(depth?: int): unknown[];
+    forEach(callback: (value: T) => void): void;
+    forEach(callback: (value: T, index: int) => void): void;
+    includes(searchElement: T): boolean;
+    includes(searchElement: T, fromIndex?: int): boolean;
+    indexOf(searchElement: T, fromIndex?: int): int;
+    join(separator?: string): string;
+    lastIndexOf(searchElement: T, fromIndex?: int): int;
+    map<TResult>(callback: (value: T) => TResult): TResult[];
+    map<TResult>(callback: (value: T, index: int) => TResult): TResult[];
+    reduce(callback: (previousValue: T, currentValue: T) => T): T;
+    reduce<TResult>(
+      callback: (previousValue: TResult, currentValue: T) => TResult,
+      initialValue: TResult
+    ): TResult;
+    reduceRight<TResult>(
+      callback: (previousValue: TResult, currentValue: T) => TResult,
+      initialValue: TResult
+    ): TResult;
+    slice(start?: int, end?: int): T[];
+    some(callback: (value: T) => boolean): boolean;
+  }
+  interface ReadonlyArray<T> {
+    readonly length: int;
+    at(index: int): T;
+    concat(...items: T[]): T[];
+    every(callback: (value: T) => boolean): boolean;
+    filter(callback: (value: T) => boolean): T[];
+    filter(callback: (value: T, index: int) => boolean): T[];
+    find(callback: (value: T) => boolean): T | undefined;
+    find(callback: (value: T, index: int) => boolean): T | undefined;
+    findIndex(callback: (value: T) => boolean): int;
+    findIndex(callback: (value: T, index: int) => boolean): int;
+    findLast(callback: (value: T) => boolean): T | undefined;
+    findLast(callback: (value: T, index: int) => boolean): T | undefined;
+    findLastIndex(callback: (value: T) => boolean): int;
+    findLastIndex(callback: (value: T, index: int) => boolean): int;
+    flat(depth?: int): unknown[];
+    forEach(callback: (value: T) => void): void;
+    forEach(callback: (value: T, index: int) => void): void;
+    includes(searchElement: T): boolean;
+    includes(searchElement: T, fromIndex?: int): boolean;
+    indexOf(searchElement: T, fromIndex?: int): int;
+    join(separator?: string): string;
+    lastIndexOf(searchElement: T, fromIndex?: int): int;
+    map<TResult>(callback: (value: T) => TResult): TResult[];
+    map<TResult>(callback: (value: T, index: int) => TResult): TResult[];
+    reduce(callback: (previousValue: T, currentValue: T) => T): T;
+    reduce<TResult>(
+      callback: (previousValue: TResult, currentValue: T) => TResult,
+      initialValue: TResult
+    ): TResult;
+    reduceRight<TResult>(
+      callback: (previousValue: TResult, currentValue: T) => TResult,
+      initialValue: TResult
+    ): TResult;
+    slice(start?: int, end?: int): T[];
+    some(callback: (value: T) => boolean): boolean;
+  }
+  interface Console {
+    log(...data: unknown[]): void;
+    error(...data: unknown[]): void;
+    warn(...data: unknown[]): void;
+    info(...data: unknown[]): void;
+    debug(...data: unknown[]): void;
+  }
+  const console: Console;
+  interface Date {
+    toISOString(): string;
+    getTime(): long;
+  }
+  interface DateConstructor {
+    new (): Date;
+    new (value: string | number | long): Date;
+    now(): long;
+    parse(s: string): long;
+  }
+  const Date: DateConstructor;
+  interface JSON {
+    parse<T = unknown>(text: string): T;
+    stringify(
+      value: unknown,
+      replacer?: unknown,
+      space?: string | number | int
+    ): string;
+  }
+  const JSON: JSON;
+  interface Math {
+    round(x: double): double;
+    max(...values: double[]): double;
+    min(...values: double[]): double;
+    random(): double;
+  }
+  const Math: Math;
+  interface RegExpMatchArray extends Array<string> {
+    index?: int;
+    input?: string;
+  }
+  interface RegExp {
+    exec(string: string): RegExpMatchArray | null;
+    test(string: string): boolean;
+  }
+  interface RegExpConstructor {
+    new (pattern: string | RegExp, flags?: string): RegExp;
+    (pattern: string | RegExp, flags?: string): RegExp;
+  }
+  const RegExp: RegExpConstructor;
+  interface Map<K, V> {
+    readonly size: int;
+    clear(): void;
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+  }
+  interface MapConstructor {
+    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+  }
+  const Map: MapConstructor;
+  interface Set<T> {
+    readonly size: int;
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+  }
+  interface SetConstructor {
+    new <T = unknown>(values?: readonly T[] | null): Set<T>;
+  }
+  const Set: SetConstructor;
+  function parseInt(str: string, radix?: int): long | undefined;
+  function parseFloat(str: string): double;
+  function isFinite(value: double): boolean;
+  function isNaN(value: double): boolean;
+  function setTimeout(
+    handler: (...args: unknown[]) => void,
+    timeout?: int,
+    ...args: unknown[]
+  ): int;
+  function clearTimeout(id: int): void;
+  function setInterval(
+    handler: (...args: unknown[]) => void,
+    timeout?: int,
+    ...args: unknown[]
+  ): int;
+  function clearInterval(id: int): void;
+}
+
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsonic/js",
-  "version": "10.0.37",
+  "version": "10.0.39",
   "description": "TypeScript type definitions for JavaScript Runtime (JSRuntime) library",
   "type": "module",
   "keywords": [

package/tsonic.bindings.json

@@ -1,4 +1,10 @@
 {
+  "bindingVersion": 1,
+  "packageName": "@tsonic/js",
+  "surfaceMode": "js",
+  "runtimePackages": [
+    "@tsonic/js"
+  ],
   "dotnet": {
     "packageReferences": [
       { "id": "Tsonic.JSRuntime", "version": "0.0.3", "types": "@tsonic/js" }

package/tsonic.surface.json

@@ -0,0 +1,7 @@
+{
+  "schemaVersion": 1,
+  "id": "@tsonic/js",
+  "extends": [],
+  "requiredTypeRoots": ["."],
+  "useStandardLib": false
+}