@tsonic/globals 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tsoniclang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# @tsonic/globals
+
+Global type definitions for Tsonic.
+
+This package provides:
+1. **Base types** required by TypeScript (Array, String, Object, Function, etc.)
+2. **Shared types** used by both modes (utility types, iterators, Promise, Symbol)
+
+## Usage
+
+### Dotnet mode (use this package alone)
+
+```bash
+npm install @tsonic/globals
+```
+
+```json
+{
+  "compilerOptions": {
+    "noLib": true,
+    "typeRoots": ["node_modules/@tsonic/globals"]
+  }
+}
+```
+
+Arrays use LINQ, strings use BCL methods.
+
+### JS mode (use with @tsonic/js-globals)
+
+```bash
+npm install @tsonic/globals @tsonic/js-globals
+```
+
+```json
+{
+  "compilerOptions": {
+    "noLib": true,
+    "typeRoots": [
+      "node_modules/@tsonic/globals",
+      "node_modules/@tsonic/js-globals"
+    ]
+  }
+}
+```
+
+Arrays have `.map`, `.filter`, `.length`, etc. Strings have `.slice`, `.indexOf`, etc.
+
+## What's included
+
+### Base types (minimal definitions)
+- `Array<T>`, `ReadonlyArray<T>` - indexer and iterator only
+- `String`, `Number`, `Boolean` - empty base
+- `Object`, `Function` - minimal
+- `RegExp`, `IArguments`, `CallableFunction`, `NewableFunction`
+
+### Utility types
+- `Partial`, `Required`, `Readonly`, `Pick`, `Omit`
+- `Record`, `Exclude`, `Extract`, `NonNullable`
+- `Parameters`, `ReturnType`, `InstanceType`, `ConstructorParameters`
+
+### Iterator/Generator types
+- `Iterator`, `IteratorResult`, `Iterable`, `IterableIterator`
+- `AsyncIterator`, `AsyncIterable`, `AsyncIterableIterator`
+- `Generator`, `AsyncGenerator`
+
+### Promise types
+- `Promise`, `PromiseLike`, `PromiseConstructor`
+
+### Other
+- `Symbol`, `SymbolConstructor`
+- `PropertyKey`
+- Template literal utilities: `Uppercase`, `Lowercase`, `Capitalize`, `Uncapitalize`
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,212 @@
+/**
+ * @tsonic/globals
+ *
+ * Global type definitions for Tsonic.
+ *
+ * This package provides:
+ * 1. Base types required by TypeScript (Array, String, Object, Function, etc.)
+ * 2. Shared types used by both modes (utility types, iterators, Promise, Symbol)
+ *
+ * For dotnet mode: Use this package alone. Arrays use LINQ, strings use BCL.
+ * For JS mode: Use with @tsonic/js-globals which extends base types with JS methods.
+ */
+
+declare global {
+  /**
+   * Array type - minimal base definition
+   * In dotnet mode, use List<T> methods or LINQ
+   * In JS mode, @tsonic/js-globals extends this with .map, .filter, etc.
+   */
+  interface Array<T> {
+    [n: number]: T;
+    [Symbol.iterator](): IterableIterator<T>;
+  }
+
+  interface ReadonlyArray<T> {
+    readonly [n: number]: T;
+    [Symbol.iterator](): IterableIterator<T>;
+  }
+
+  /**
+   * String - minimal base definition
+   * In dotnet mode, use System.String BCL methods
+   * In JS mode, @tsonic/js-globals extends this with .length, .slice, etc.
+   */
+  interface String {}
+
+  interface Number {}
+
+  interface Boolean {}
+
+  /**
+   * Object - minimal base definition
+   */
+  interface Object {
+    constructor: Function;
+  }
+
+  /**
+   * Function - minimal base definition
+   */
+  interface Function {
+    prototype: any;
+  }
+
+  /**
+   * Required TypeScript compiler internals
+   */
+  interface CallableFunction extends Function {}
+  interface NewableFunction extends Function {}
+  interface IArguments {}
+
+  /**
+   * RegExp - minimal base definition
+   */
+  interface RegExp {}
+
+  /**
+   * Symbol
+   */
+  interface SymbolConstructor {
+    readonly iterator: symbol;
+    readonly asyncIterator: symbol;
+    readonly hasInstance: symbol;
+    readonly isConcatSpreadable: symbol;
+    readonly species: symbol;
+    readonly toPrimitive: symbol;
+    readonly toStringTag: symbol;
+  }
+
+  const Symbol: SymbolConstructor;
+
+  /**
+   * PropertyKey - required for index signatures
+   */
+  type PropertyKey = string | number | symbol;
+
+  /**
+   * Utility types
+   */
+  type Partial<T> = { [P in keyof T]?: T[P] };
+  type Required<T> = { [P in keyof T]-?: T[P] };
+  type Readonly<T> = { readonly [P in keyof T]: T[P] };
+  type Pick<T, K extends keyof T> = { [P in K]: T[P] };
+  type Record<K extends keyof any, T> = { [P in K]: T };
+  type Exclude<T, U> = T extends U ? never : T;
+  type Extract<T, U> = T extends U ? T : never;
+  type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+  type NonNullable<T> = T extends null | undefined ? never : T;
+  type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
+  type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;
+  type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
+  type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;
+
+  /**
+   * Promise types
+   */
+  interface Promise<T> {
+    then<TResult1 = T, TResult2 = never>(
+      onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+      onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+    ): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(
+      onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null
+    ): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+  }
+
+  interface PromiseLike<T> {
+    then<TResult1 = T, TResult2 = never>(
+      onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+      onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+    ): PromiseLike<TResult1 | TResult2>;
+  }
+
+  interface PromiseConstructor {
+    new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+    resolve(): Promise<void>;
+    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+    reject<T = never>(reason?: any): Promise<T>;
+    all<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
+    race<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T>;
+  }
+
+  const Promise: PromiseConstructor;
+
+  /**
+   * Iterator types
+   */
+  interface Iterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return?(value?: TReturn): IteratorResult<T, TReturn>;
+    throw?(e?: any): IteratorResult<T, TReturn>;
+  }
+
+  interface IteratorResult<T, TReturn = any> {
+    done: boolean;
+    value: T | TReturn;
+  }
+
+  interface IteratorYieldResult<T> {
+    done: false;
+    value: T;
+  }
+
+  interface IteratorReturnResult<TReturn> {
+    done: true;
+    value: TReturn;
+  }
+
+  interface Iterable<T, TReturn = any, TNext = undefined> {
+    [Symbol.iterator](): Iterator<T, TReturn, TNext>;
+  }
+
+  interface IterableIterator<T, TReturn = any, TNext = undefined> extends Iterator<T, TReturn, TNext> {
+    [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
+  }
+
+  /**
+   * Async Iterator types
+   */
+  interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return?(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
+  }
+
+  interface AsyncIterable<T, TReturn = any, TNext = undefined> {
+    [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>;
+  }
+
+  interface AsyncIterableIterator<T, TReturn = any, TNext = undefined> extends AsyncIterator<T, TReturn, TNext> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
+  }
+
+  /**
+   * Generator types
+   */
+  interface Generator<T = unknown, TReturn = any, TNext = unknown> extends Iterator<T, TReturn, TNext> {
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return(value: TReturn): IteratorResult<T, TReturn>;
+    throw(e: any): IteratorResult<T, TReturn>;
+    [Symbol.iterator](): Generator<T, TReturn, TNext>;
+  }
+
+  interface AsyncGenerator<T = unknown, TReturn = any, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw(e: any): Promise<IteratorResult<T, TReturn>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+  }
+
+  /**
+   * Template literal type utilities
+   */
+  type Uppercase<S extends string> = intrinsic;
+  type Lowercase<S extends string> = intrinsic;
+  type Capitalize<S extends string> = intrinsic;
+  type Uncapitalize<S extends string> = intrinsic;
+}
+
+// This export is required to make this file a module
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tsonic/globals",
+  "version": "0.1.0",
+  "description": "Shared global type definitions for Tsonic (utility types, iterators, Promise, Symbol)",
+  "main": "index.d.ts",
+  "types": "index.d.ts",
+  "files": [
+    "index.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "tsonic",
+    "typescript",
+    "types",
+    "globals",
+    "utility-types"
+  ],
+  "author": "Tsonic Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tsoniclang/globals.git"
+  }
+}