@bedrock-apis/env-types 1.0.0-beta.5 → 1.0.0-rc.1

package/README.md

@@ -1,5 +1,7 @@
 # env-types
 
+[![npm version](https://badge.fury.io/js/@bedrock-apis%2Fenv-types.svg)](https://www.npmjs.com/package/@bedrock-apis/env-types)
+
 TypeScript type definitions for environment-specific QuickJS engine that doesn't strictly follow standard ES versioning. This package provides a curated set of global types and methods tailored for non-standard runtimes, ensuring better development experience and type safety for your projects.  
 
 > **Note:** This package is currently in **beta**. Contributions, bug reports, and suggestions are highly appreciated! Check out our [GitHub repository](https://github.com/bedrock-apis/env-types) for more information.
@@ -12,23 +14,42 @@ TypeScript type definitions for environment-specific QuickJS engine that doesn't
 - Helps catch runtime errors early by providing accurate type safety.
 - Designed to supplement and compare against TypeScript's global types.
 
-# Installation
-Install the package as a development dependency, and add it to the known types in your `tsconfig.json`:
+## Installation
+
+Install the package as a development dependency using your preferred package manager:
+
+### npm
+```bash
+npm install --save-dev @bedrock-apis/env-types
+```
+
+### pnpm
+```bash
+pnpm add -D @bedrock-apis/env-types
+```
+
+### yarn
+```bash
+yarn add --dev @bedrock-apis/env-types
+```
+
+### Configuration
+
+Add the package to the `types` field in your `tsconfig.json`:
+
 ```json
 {
     "compilerOptions": {
         "noLib": true,
-        "types": ["@bedrock-apis/env-types"],
-        // ...
+        "types": ["@bedrock-apis/env-types"]
     }
-    // ...
 }
 ```
 
-## Plan
+## Development Plan
 
 - Generate a basic set of methods and properties for each global class.
-- Compare and extend these definitions against TypeScript’s standard global types.
+- Compare and extend these definitions against TypeScript's standard global types.
 - Continuously update with help of contributions.
 
 ## Contributing

package/lib.d.ts

@@ -2969,6 +2969,230 @@ interface String {
     replaceAll(searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
 }
 
+interface WeakRef<T extends WeakKey> {
+    readonly [Symbol.toStringTag]: "WeakRef";
+    /**
+     * Returns the WeakRef instance's target value, or undefined if the target value has been
+     * reclaimed.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
+     */
+    deref(): T | undefined;
+}
+interface WeakRefConstructor {
+    readonly prototype: WeakRef<any>;
+    /**
+     * Creates a WeakRef instance for the given target value.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
+     * @param target The target value for the WeakRef instance.
+     */
+    new <T extends WeakKey>(target: T): WeakRef<T>;
+}
+declare var WeakRef: WeakRefConstructor;
+interface FinalizationRegistry<T> {
+    readonly [Symbol.toStringTag]: "FinalizationRegistry";
+    /**
+     * Registers a value with the registry.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
+     * @param target The target value to register.
+     * @param heldValue The value to pass to the finalizer for this value. This cannot be the
+     * target value.
+     * @param unregisterToken The token to pass to the unregister method to unregister the target
+     * value. If not provided, the target cannot be unregistered.
+     */
+    register(target: WeakKey, heldValue: T, unregisterToken?: WeakKey): void;
+    /**
+     * Unregisters a value from the registry.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
+     * @param unregisterToken The token that was used as the unregisterToken argument when calling
+     * register to register the target value.
+     */
+    unregister(unregisterToken: WeakKey): boolean;
+}
+interface FinalizationRegistryConstructor {
+    readonly prototype: FinalizationRegistry<any>;
+    /**
+     * Creates a finalization registry with an associated cleanup callback
+     * @param cleanupCallback The callback to call after a value in the registry has been reclaimed.
+     */
+    new <T>(cleanupCallback: (heldValue: T) => void): FinalizationRegistry<T>;
+}
+declare var FinalizationRegistry: FinalizationRegistryConstructor;
+
+interface Array<T> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): T | undefined;
+}
+interface ReadonlyArray<T> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): T | undefined;
+}
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): bigint | undefined;
+}
+interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): bigint | undefined;
+}
+
+interface ErrorOptions {
+    cause?: unknown;
+}
+interface Error {
+    cause?: unknown;
+}
+interface ErrorConstructor {
+    new (message?: string, options?: ErrorOptions): Error;
+    (message?: string, options?: ErrorOptions): Error;
+}
+interface EvalErrorConstructor {
+    new (message?: string, options?: ErrorOptions): EvalError;
+    (message?: string, options?: ErrorOptions): EvalError;
+}
+interface RangeErrorConstructor {
+    new (message?: string, options?: ErrorOptions): RangeError;
+    (message?: string, options?: ErrorOptions): RangeError;
+}
+interface ReferenceErrorConstructor {
+    new (message?: string, options?: ErrorOptions): ReferenceError;
+    (message?: string, options?: ErrorOptions): ReferenceError;
+}
+interface SyntaxErrorConstructor {
+    new (message?: string, options?: ErrorOptions): SyntaxError;
+    (message?: string, options?: ErrorOptions): SyntaxError;
+}
+interface TypeErrorConstructor {
+    new (message?: string, options?: ErrorOptions): TypeError;
+    (message?: string, options?: ErrorOptions): TypeError;
+}
+interface URIErrorConstructor {
+    new (message?: string, options?: ErrorOptions): URIError;
+    (message?: string, options?: ErrorOptions): URIError;
+}
+interface AggregateErrorConstructor {
+    new (
+        errors: Iterable<any>,
+        message?: string,
+        options?: ErrorOptions,
+    ): AggregateError;
+    (
+        errors: Iterable<any>,
+        message?: string,
+        options?: ErrorOptions,
+    ): AggregateError;
+}
+
+interface ObjectConstructor {
+    /**
+     * Determines whether an object has a property with the specified name.
+     * @param o An object.
+     * @param v A property name.
+     */
+    hasOwn(o: object, v: PropertyKey): boolean;
+}
+
+interface RegExpMatchArray {
+    indices?: RegExpIndicesArray;
+}
+interface RegExpExecArray {
+    indices?: RegExpIndicesArray;
+}
+interface RegExpIndicesArray extends Array<[number, number]> {
+    groups?: {
+        [key: string]: [number, number];
+    };
+}
+interface RegExp {
+    /**
+     * Returns a Boolean value indicating the state of the hasIndices flag (d) used with a regular expression.
+     * Default is false. Read-only.
+     */
+    readonly hasIndices: boolean;
+}
+
+interface String {
+    /**
+     * Returns a new String consisting of the single UTF-16 code unit located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): string | undefined;
+}
+
 interface Array<T> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@bedrock-apis/env-types",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-rc.1",
   "description": "A collection of environment-specific TypeScript type definitions for engines with non-standard versioning and selective feature support across versions.",
   "main": "",
   "types": "lib.d.ts",
+  "type": "module",
   "keywords": [
     "typescript",
     "api-types",