@moddable/typings 8.3.0 → 9.0.0

package/embedded/sensor/Barometer-Humidity-Temperature/BME280.d.ts

@@ -0,0 +1,102 @@
+/*
+* Copyright (c) 2026 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "embedded:sensor/Barometer-Humidity-Temperature/BME280" {
+  interface BME280IO {
+    write(buffer: ArrayBuffer | ArrayBufferView, stop?: boolean): void;
+    read(buffer: ArrayBuffer | ArrayBufferView): void;
+    close(): void;
+  }
+
+  interface BME280SensorOptions {
+    io: new (options: object) => BME280IO;
+    address?: number;
+    hz?: number;
+    data?: number | string;
+    clock?: number | string;
+    [key: string]: unknown;
+  }
+
+  interface BME280Options {
+    sensor: BME280SensorOptions;
+    target?: unknown;
+  }
+
+  interface BME280Configuration {
+    mode?: number;
+    temperatureSampling?: number;
+    pressureSampling?: number;
+    humiditySampling?: number;
+    filter?: number;
+    standbyDuration?: number;
+  }
+
+  interface BME280Sample {
+    thermometer: { temperature: number };
+    hygrometer: { humidity?: number };
+    barometer: { pressure: number };
+  }
+
+  interface BME280ConfigConstants {
+    readonly Sampling: {
+      readonly SKIPPED: 0x00;
+      readonly X1: 0x01;
+      readonly X2: 0x02;
+      readonly X4: 0x03;
+      readonly X8: 0x04;
+      readonly X16: 0x05;
+    };
+    readonly Filter: {
+      readonly OFF: 0x00;
+      readonly X2: 0x01;
+      readonly X4: 0x02;
+      readonly X8: 0x03;
+      readonly X16: 0x04;
+    };
+    readonly Mode: {
+      readonly SLEEP: 0x00;
+      readonly FORCED: 0x01;
+      readonly NORMAL: 0x03;
+    };
+    readonly Standby: {
+      readonly MS_0_5: 0x00;
+      readonly MS_62_5: 0x01;
+      readonly MS_125: 0x02;
+      readonly MS_250: 0x03;
+      readonly MS_500: 0x04;
+      readonly MS_1000: 0x05;
+      readonly MS_10: 0x06;
+      readonly MS_20: 0x07;
+    };
+  }
+
+  class BME280 {
+    constructor(options: BME280Options);
+    configure(options: BME280Configuration): void;
+    sample(): BME280Sample;
+    close(): void;
+    target?: unknown;
+  }
+  interface BME280 extends Disposable {}
+
+  const Config: BME280ConfigConstants;
+
+  export { BME280 as default, BME280, Config };
+}

package/embedded/sensor/Location/fixed.d.ts

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026 Moddable Tech, Inc.
+ */
+
+import type {
+	LocationConfiguration,
+	LocationOptions,
+	LocationSample,
+	LocationSensor
+} from "./location";
+
+export interface FixedOptions extends LocationOptions {
+	latitude: number;
+	longitude: number;
+	altitude?: number;
+	accuracy?: number;
+}
+
+export interface FixedConfiguration extends LocationConfiguration {
+	latitude?: number;
+	longitude?: number;
+	altitude?: number;
+	accuracy?: number;
+}
+
+declare class Fixed implements LocationSensor {
+	constructor(options: FixedOptions);
+	configure(options: FixedConfiguration): void;
+	sample(): LocationSample | undefined;
+	close(): void;
+	readonly identification: {
+		model: string;
+		classification: string;
+		description: string;
+	};
+}
+interface Fixed extends Disposable {}
+
+export default Fixed;

package/embedded/sensor/Location/ip.d.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026 Moddable Tech, Inc.
+ */
+
+import type {
+	LocationConfiguration,
+	LocationOptions,
+	LocationSample,
+	LocationSensor
+} from "./location";
+
+export interface IPOptions extends LocationOptions {
+	endpoint?: string;
+	host?: string;
+	path?: string;
+	port?: number;
+	headers?: Map<string, string> | Record<string, string>;
+	http?: object;
+	parse?: (json: unknown) => LocationSample | undefined;
+	defaultAccuracy?: number;
+	interval?: number;
+}
+
+export interface IPConfiguration extends LocationConfiguration {
+	endpoint?: string;
+	host?: string;
+	path?: string;
+	interval?: number;
+}
+
+declare class IP implements LocationSensor {
+	constructor(options: IPOptions);
+	configure(options: IPConfiguration): void;
+	sample(): LocationSample | undefined;
+	close(): void;
+	readonly identification: {
+		model: string;
+		classification: string;
+		description: string;
+	};
+}
+interface IP extends Disposable {}
+
+export default IP;

package/embedded/sensor/Location/location.d.ts

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026 Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Tools.
+ *
+ *   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Tools is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/** ECMA-419 Location sample (W3C Geolocation-shaped). */
+export interface LocationSample {
+	latitude: number;
+	longitude: number;
+	altitude?: number;
+	accuracy?: number;
+	altitudeAccuracy?: number;
+	heading?: number;
+	speed?: number;
+	timestamp?: number;
+}
+
+export interface LocationIdentification {
+	model: string;
+	classification: string;
+	description: string;
+}
+
+export interface LocationConfiguration {
+	enableHighAccuracy?: boolean;
+	timeout?: number;
+	maximumAge?: number;
+}
+
+export interface LocationOptions {
+	onSample?: () => void;
+	onError?: (error: Error) => void;
+	target?: unknown;
+}
+
+export interface LocationSensor {
+	configure(options: LocationConfiguration): void;
+	sample(): LocationSample | undefined;
+	close(): void;
+	readonly identification: LocationIdentification;
+}

package/embedded/sensor/RFID/mfrc522-spi.d.ts

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026 Moddable Tech, Inc.
+ */
+
+export interface RFIDSample {
+	present: boolean;
+	uid?: Uint8Array;
+	uidHex?: string;
+	sak?: number;
+	type?: string;
+}
+
+export interface MFRC522SPIOptions {
+	sensor: {
+		io: new (options: object) => object;
+		clock?: number;
+		in?: number;
+		out?: number;
+		port?: number;
+		hz?: number;
+		mode?: number;
+		[key: string]: unknown;
+	};
+	select: {
+		io: new (options: object) => { write(v: number): void; close(): void };
+		pin: number;
+		mode?: number;
+		[key: string]: unknown;
+	};
+	reset?: {
+		io: new (options: object) => { write(v: number): void; close(): void };
+		pin: number;
+		mode?: number;
+		[key: string]: unknown;
+	};
+	onSample?: () => void;
+	onError?: (error: Error) => void;
+	target?: unknown;
+	interval?: number;
+}
+
+export interface MFRC522SPIConfiguration {
+	interval?: number;
+	antenna?: boolean;
+}
+
+declare class MFRC522SPI {
+	constructor(options: MFRC522SPIOptions);
+	configure(options: MFRC522SPIConfiguration): void;
+	sample(): RFIDSample | undefined;
+	close(): void;
+	readonly identification: {
+		model: string;
+		classification: string;
+		description: string;
+	};
+	readonly version: number;
+	authenticate(): never;
+	readBlock(): never;
+	writeBlock(): never;
+}
+interface MFRC522SPI extends Disposable {}
+
+export default MFRC522SPI;

package/embedded/sensor/RFID/mfrc522.d.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026 Moddable Tech, Inc.
+ */
+
+export interface RFIDSample {
+	present: boolean;
+	uid?: Uint8Array;
+	uidHex?: string;
+	sak?: number;
+	type?: string;
+}
+
+export interface MFRC522Options {
+	sensor: {
+		io: new (options: object) => object;
+		data?: number;
+		clock?: number;
+		address?: number;
+		hz?: number;
+		[key: string]: unknown;
+	};
+	onSample?: () => void;
+	onError?: (error: Error) => void;
+	target?: unknown;
+	interval?: number;
+}
+
+export interface MFRC522Configuration {
+	interval?: number;
+	antenna?: boolean;
+}
+
+declare class MFRC522 {
+	constructor(options: MFRC522Options);
+	configure(options: MFRC522Configuration): void;
+	sample(): RFIDSample | undefined;
+	close(): void;
+	readonly identification: {
+		model: string;
+		classification: string;
+		description: string;
+	};
+	readonly version: number;
+	authenticate(): never;
+	readBlock(): never;
+	writeBlock(): never;
+}
+interface MFRC522 extends Disposable {}
+
+export default MFRC522;

package/embedded/storage/key-value.d.ts

@@ -33,8 +33,8 @@ declare module "embedded:storage/key-value" {
 
 		delete(key: string): void;
 
-		read(key: string): ArrayBuffer | string | number | bigint;
-		read(key: string, buffer: ByteBuffer): number;
+		read(key: string): ArrayBuffer | string | number | bigint | undefined;
+		read(key: string, buffer: ByteBuffer): number | undefined;
 		write(key: string, value: ByteBuffer | string | number | bigint): void;
 
 		[Symbol.iterator](): IterableIterator<string>;

package/embedded_io/socket/tcp/tls.d.ts

@@ -1,17 +1,54 @@
 declare module "embedded:io/socket/tcp/tls" {
-  import { Options as TCPOptions } from "embedded:io/socket/tcp"
-  export type Options = TCPOptions & {
+  import TCP, { Options as TCPOptions } from "embedded:io/socket/tcp"
+
+  export type TLSVersion = "TLSv1.1" | "TLSv1.2" | "TLSv1.3"
+
+  export type TLSOptions = {
+    /** Server Name Indication (SNI) and the name certificates are validated against. */
     host: string
-    secure: Record<string, any> // should be called "tls" according to std?
+    minimumVersion?: TLSVersion
+    maximumVersion?: TLSVersion
+    /** Application-Layer Protocol Negotiation (ALPN). */
+    applicationLayerProtocol?: string | ByteBuffer | Array<string | ByteBuffer>
+    maximumFragmentLength?: number
+    ca?: ByteBuffer | ByteBuffer[]
+    clientKey?: ByteBuffer | ByteBuffer[]
+    clientCertificate?: ByteBuffer | ByteBuffer[]
+
+    // Moddable SDK extensions
+    /** Trace TLS protocol activity. Defaults to `false`. */
+    trace?: boolean
+    /** Verify the server's certificate chain. Defaults to `true`. Never disable in production. */
+    verify?: boolean
+  }
+
+  /** Extends the TCP socket's options object. Listed explicitly so the callbacks
+      can be typed with `this` as the TLS socket rather than the TCP socket. */
+  export type Options = {
+    address: string
+    port: number
+    noDelay?: boolean
+    format?: "number" | "buffer"
+    target?: any
+    onReadable?: (this: TLSSocket, bytes: number) => void
+    onWritable?: (this: TLSSocket, bytes: number) => void
+    onError?: (this: TLSSocket) => void
+
+    tls: TLSOptions
+    /** The TCP socket this TLS socket runs over. A Moddable SDK extension. */
+    TCP: { io: new (options: TCPOptions) => TCP } & Partial<TCPOptions>
   }
-  export default class TLSSocket {
+
+  class TLSSocket {
     constructor(options: Options)
     close(): void
-    read(count: number|ArrayBufferLike) : undefined|ArrayBufferLike
-    write(buffer: ArrayBufferLike) : number
-    set format(format: string)
-    get format() : string
+    read(): number | ArrayBuffer
+    read(byteLength: number): ArrayBuffer
+    read(buffer: ByteBuffer): number
+    write(buffer: ByteBuffer, options?: { more?: boolean, byteLength?: number }): number
+    get format(): "number" | "buffer"
+    set format(value: "number" | "buffer")
   }
   interface TLSSocket extends Disposable {}
+  export default TLSSocket;
 }
-

package/embedded_io/socket/tcp.d.ts

@@ -19,16 +19,13 @@
 */
 
 declare module "embedded:io/socket/tcp" {
-  export type Options = ((({
+  export type Options = (({
     address: string;
-  } | {
-    host: string;
-  }) & {
     port: number;
   }) | {
     from: TCP;
   }) & {
-    nodelay?: boolean;
+    noDelay?: boolean;
     onReadable?: (this: TCP, bytes: number) => void;
     onWritable?: (this: TCP, bytes: number) => void;
     onError?: (this: TCP) => void;
@@ -40,9 +37,10 @@ declare module "embedded:io/socket/tcp" {
     constructor(options: Options)
     readonly remoteAddress: string | undefined;
     readonly remotePort: number | undefined;
-    read(byteLength?: number): number | ArrayBuffer;
-    read(buffer: ByteBuffer): void;
-    write(value: number | ByteBuffer): void;
+    read(): number | ArrayBuffer;
+    read(byteLength: number): ArrayBuffer;
+    read(buffer: ByteBuffer): number;
+    write(value: number | ByteBuffer): number;
     close(): void;
     get format(): "number" | "buffer"
     set format(value: "number" | "buffer")

package/embedded_network/interface/wifi.d.ts

@@ -43,6 +43,7 @@ declare module "embedded:network/interface/wifi" {
 	export interface WiFiConnectOptions {
 		SSID: string;
 		password?: string;
+		secure?: boolean;
 	}
 
 	export interface WiFiStaticAddress {

package/mcpack.d.ts

@@ -18,32 +18,29 @@
  *
  */
 
+/// <reference path="./web/abortsignal.d.ts" />
+/// <reference path="./web/console.d.ts" />
+/// <reference path="./web/decompressionstream.d.ts" />
+/// <reference path="./web/domexception.d.ts" />
 /// <reference path="./web/eventsource.d.ts" />
 /// <reference path="./web/fetch.d.ts" />
 /// <reference path="./web/headers.d.ts" />
+/// <reference path="./web/streams.d.ts" />
 /// <reference path="./web/structuredClone.d.ts" />
+/// <reference path="./web/textdecoderstream.d.ts" />
+/// <reference path="./web/textencoderstream.d.ts" />
+/// <reference path="./web/timers.d.ts" />
 /// <reference path="./web/url.d.ts" />
-/// <reference path="./web/worker.d.ts" />
 /// <reference path="./web/websocket.d.ts" />
+/// <reference path="./web/websocketstream.d.ts" />
 /// <reference path="./web/webstorage.d.ts" />
+/// <reference path="./web/worker.d.ts" />
 /// <reference path="./text/decoder.d.ts" />
 /// <reference path="./text/encoder.d.ts" />
 
-import type Timer from "timer";
-
-interface Console {
-	log(...log: (string | number | boolean)[]):void;
-}
+export {};
 
 declare global {
-	const console: Console;
-	const clearImmediate: (timer: Timer) => void;
-	const clearInterval: (timer: Timer) => void;
-	const clearTimeout: (timer: Timer) => void;
-	const setImmediate: (handler: Function) => Timer;
-	const setInterval: (handler: Function, timeout?: number) => Timer;
-	const setTimeout: (handler: Function, timeout?: number) => Timer;
-
 	const EventSource: typeof import("web/eventsource").default;
 	type EventSource = import("web/eventsource").default;
 
@@ -76,5 +73,65 @@ declare global {
 
 	const SharedWorker: typeof import("worker").SharedWorker;
 	type SharedWorker = import("worker").SharedWorker;
+
+	const AbortController: typeof import("web/abortsignal").AbortController;
+	type AbortController = import("web/abortsignal").AbortController;
+
+	const AbortSignal: typeof import("web/abortsignal").AbortSignal;
+	type AbortSignal = import("web/abortsignal").AbortSignal;
+
+	const DOMException: typeof import("web/domexception").DOMException;
+	type DOMException = import("web/domexception").DOMException;
+
+	const ReadableStream: typeof import("web/streams").ReadableStream;
+	type ReadableStream<R = any> = import("web/streams").ReadableStream<R>;
+
+	const ReadableStreamDefaultReader: typeof import("web/streams").ReadableStreamDefaultReader;
+	type ReadableStreamDefaultReader<R = any> = import("web/streams").ReadableStreamDefaultReader<R>;
+
+	const ReadableStreamBYOBReader: typeof import("web/streams").ReadableStreamBYOBReader;
+	type ReadableStreamBYOBReader = import("web/streams").ReadableStreamBYOBReader;
+
+	const ReadableStreamDefaultController: typeof import("web/streams").ReadableStreamDefaultController;
+	type ReadableStreamDefaultController<R = any> = import("web/streams").ReadableStreamDefaultController<R>;
+
+	const ReadableByteStreamController: typeof import("web/streams").ReadableByteStreamController;
+	type ReadableByteStreamController = import("web/streams").ReadableByteStreamController;
+
+	const ReadableStreamBYOBRequest: typeof import("web/streams").ReadableStreamBYOBRequest;
+	type ReadableStreamBYOBRequest = import("web/streams").ReadableStreamBYOBRequest;
+
+	const WritableStream: typeof import("web/streams").WritableStream;
+	type WritableStream<W = any> = import("web/streams").WritableStream<W>;
+
+	const WritableStreamDefaultWriter: typeof import("web/streams").WritableStreamDefaultWriter;
+	type WritableStreamDefaultWriter<W = any> = import("web/streams").WritableStreamDefaultWriter<W>;
+
+	const WritableStreamDefaultController: typeof import("web/streams").WritableStreamDefaultController;
+	type WritableStreamDefaultController = import("web/streams").WritableStreamDefaultController;
+
+	const TransformStream: typeof import("web/streams").TransformStream;
+	type TransformStream<I = any, O = any> = import("web/streams").TransformStream<I, O>;
+
+	const TransformStreamDefaultController: typeof import("web/streams").TransformStreamDefaultController;
+	type TransformStreamDefaultController<O = any> = import("web/streams").TransformStreamDefaultController<O>;
+
+	const ByteLengthQueuingStrategy: typeof import("web/streams").ByteLengthQueuingStrategy;
+	type ByteLengthQueuingStrategy = import("web/streams").ByteLengthQueuingStrategy;
+
+	const CountQueuingStrategy: typeof import("web/streams").CountQueuingStrategy;
+	type CountQueuingStrategy = import("web/streams").CountQueuingStrategy;
+
+	const DecompressionStream: typeof import("web/decompressionstream").default;
+	type DecompressionStream = import("web/decompressionstream").default;
+
+	const TextDecoderStream: typeof import("web/textdecoderstream").default;
+	type TextDecoderStream = import("web/textdecoderstream").default;
+
+	const TextEncoderStream: typeof import("web/textencoderstream").default;
+	type TextEncoderStream = import("web/textencoderstream").default;
+
+	const WebSocketStream: typeof import("web/websocketstream").default;
+	type WebSocketStream = import("web/websocketstream").default;
 }
 

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "@moddable/typings",
-	"version": "8.3.0",
+	"version": "9.0.0",
 	"main": "",
-	"types": [
-		"xs.d.ts",
-		"mcpack.d.ts"
-	],
-	"author": "",
+	"types": "xs",
+	"typesVersions": {
+		">=6.0.0-0": { "tsconfig.base.json": ["./tsconfig.es2025.json"] },
+		">=5.4.0-0": { "tsconfig.base.json": ["./tsconfig.es2024.json"] }
+	},
+	"author": "Moddable",
 	"license": "ISC",
 	"description": ""
 }

package/piu/ImageBuffer.d.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+declare module "piu/ImageBuffer" {
+  import { Content, ContentDictionary } from "piu/MC";
+
+  interface ImageBuffer extends Content {
+    buffer: ByteBuffer;
+  }
+  interface ImageBufferDictionary extends ContentDictionary {
+    imageType?: number;
+    imageWidth: number;
+    imageHeight: number;
+  }
+  interface ImageBufferConstructor {
+    new(behaviorData?: any, dictionary?: ImageBufferDictionary): ImageBuffer;
+    (behaviorData?: any, dictionary?: ImageBufferDictionary): ImageBuffer;
+
+    template<T>(this: T, fn: (arg: any) => ImageBufferDictionary): T;
+  }
+
+  global {
+    const ImageBuffer: ImageBufferConstructor
+  }
+}

package/piu/MC-types.d.ts

@@ -77,7 +77,7 @@ export interface Behavior<T extends Content = Content> {
     onTimeChanged?(content: T): void;
     onTouchBegan?(content: T, id: number, x: number, y: number, ticks: number): void;
     onTouchCancelled?(content: T, id: number): void;
-    onTouchended?(content: T, id: number, x: number, y: number, ticks: number): void;
+    onTouchEnded?(content: T, id: number, x: number, y: number, ticks: number): void;
     onTouchMoved?(content: T, id: number, x: number, y: number, ticks: number): void;
     // TODO: complete callbacks
   }
@@ -259,9 +259,9 @@ export interface Container extends Content {
     add(content: Content): void;
     content(at: number | string): Content | undefined;
     empty(start?: number, stop?: number): void;
-    firstThat(id: string, ...extras: any[]): void;
+    firstThat(id: string, ...extras: any[]): Content | undefined;
     insert(content: Content, before: Content): void;
-    lastThat(id: string, ...extras: any[]): void;
+    lastThat(id: string, ...extras: any[]): Content | undefined;
     remove(content: Content): void;
     replace(content: Content, by: Content): void;
     run(transition: Transition, ...extras: any[]): void;
@@ -454,7 +454,7 @@ export interface LayoutConstructor extends ContainerConstructor {
 }
 
 export interface Image extends Content {
-  readonly frameCount: never;
+  readonly frameCount: number;
   frameIndex: number;
 }
 export interface ImageDictionary extends ContentDictionary {