@moddable/typings 6.1.0 → 7.1.0

package/neostrand.d.ts

@@ -0,0 +1,173 @@
+/*
+* Copyright (c) 2025 Satoshi Tanaka
+*
+*   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 "neostrand" {
+    import type NeoPixel from "neopixel";
+    import type Timeline from "piu/Timeline";
+
+    export type NeoStrandEffectDictionary = {
+        strand: NeoStrand;
+        start?: number;
+        end?: number;
+        reverse?: 0 | 1;
+        duration?: number;
+        position?: number;
+        speed?: number;
+        size?: number;
+        loop?: 0 | 1;
+        tickle?: number;
+
+        onComplete?: (effect: NeoStrandEffect) => void;
+    }
+
+    export class NeoStrandEffect {
+        name: string;
+        strand: NeoStrand;
+        start: number;
+        end: number
+        size: number;
+        dur: number;
+        reverse: 0 | 1;
+        loop: 0 | 1;
+        timeline: Timeline;
+        constructor(dictionary: NeoStrandEffectDictionary);
+
+        reset(effect: NeoStrandEffect): void;
+        loopPrepare(effect: NeoStrandEffect): void;
+        activate(effect: NeoStrandEffect): void;
+        idle(effect: NeoStrandEffect, ticks: number): void;
+    }
+
+    class HueSpan extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            position?: number;
+            saturation?: number;
+            value?: number;
+        });
+
+        set hue(h: number);
+    }
+
+    class Sine extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            amplitude?: number;
+            offset?: number;
+            vary?: "r" | "g" | "b" | "h" | "s" | "v";
+        });
+
+        set effectValue(value: number);
+    }
+
+    interface rgb {
+        r: number;
+        g: number;
+        b: number;
+    }
+    class Marquee extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            sizeA?: number;
+            sizeB?: number;
+            rgbA?: rgb;
+            rgbB?: rgb;
+        });
+
+        set steps(s: number);
+    }
+
+    class Pulse extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            dir?: number;
+            mode?: -1 | 0 | 1;
+            fade?: number;
+            size?: number;
+            duration?: number;
+            position?: "random" | number;
+            rgb?: rgb;
+        });
+
+        loopPrepare(effect: NeoStrandEffect): void;
+        set pulseLoc(px: number);
+    }
+
+    class Pattern extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            pattern?: number[];
+            mode?: -1 | 0 | 1;
+        });
+
+        loopPrepare(effect: NeoStrandEffect): void;
+        set effectValue(value: number);
+    }
+
+    class Dim extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            rgb?: rgb;
+        });
+    }
+
+    class Ease extends NeoStrandEffect {
+        constructor(dictionary: NeoStrandEffectDictionary & {
+            easing?: number;
+            size?: number;
+            rgb?: rgb;
+        });
+
+        set steps(s: number);
+    }
+
+    interface PulseTiming {
+        level0: 0 | 1;
+        duration0: number;
+        level1: 0 | 1;
+        duration1: number;
+    }
+
+    export class NeoStrand extends NeoPixel {
+        constructor(options?: {
+            pin?: number,
+            length?: number,
+            order?: string,
+            timing?: {
+                mark: PulseTiming,
+                space: PulseTiming,
+                reset: PulseTiming
+            }
+        });
+
+        set(idx: number, color: number, start?: number, end?: number): void;
+        add(idx: number, color: number, start?: number, end?: number): void;
+        sub(idx: number, color: number, start?: number, end?: number): void;
+        op(idx: number, rgb: number, mode: number, start: number, end: number): void;
+        setScheme(scheme: NeoStrandEffect[]): void;
+        start(ms?: number): void;
+        stop(): void;
+        hsvToRgb(h: number, s: number, v: number): number;
+        rgbToHsv(r: number, g: number, b: number): { h: number; s: number; v: number };
+
+        static HueSpan: typeof HueSpan;
+        static Sine: typeof Sine;
+        static Marquee: typeof Marquee;
+        static Pulse: typeof Pulse;
+        static Pattern: typeof Pattern;
+        static Dim: typeof Dim;
+        static Ease: typeof Ease;
+    }
+    
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@moddable/typings",
-	"version": "6.1.0",
+	"version": "7.1.0",
 	"main": "",
 	"types": [
 		"xs.d.ts",

package/pins/audioout.d.ts

@@ -56,7 +56,7 @@ declare module 'pins/audioout' {
     public enqueue(stream: number, kind: MixerVolume, volume: number): void
     
     public mix(samplesNeeded: number): HostBuffer
-    public mix(buffer: BufferLike): void
+    public mix(buffer: ByteBuffer): void
 
     public length(stream: number): number
   

package/qrcode.d.ts

@@ -24,7 +24,7 @@ declare module "qrcode" {
     }
 
     var qrCode: (options: {
-        input: string | BufferLike,
+        input: string | ByteBuffer,
         maxVersion?: number
     }) => qrcode;
 

package/securesocket.d.ts

@@ -21,7 +21,7 @@
 declare module "securesocket" {
     import { Socket } from "socket";
 
-    type WriteData = number | string | BufferLike;
+    type WriteData = number | string | ByteBuffer;
 
     export default class SecureSocket {
         sock: typeof Socket;

package/socket.d.ts

@@ -44,7 +44,7 @@ declare module "socket" {
     port: number,
     kind: "UDP",
   };
-  type WriteData = number | string | BufferLike;
+  type WriteData = number | string | ByteBuffer;
   
   type MessageError = -2;
   type MessageDisconnect = -1;

package/xs.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2025 Moddable Tech, Inc
+ * Copyright (c) 2020-2026 Moddable Tech, Inc
  *
  *   This file is part of the Moddable SDK Tools.
  *
@@ -35,14 +35,14 @@ interface ArrayBufferTypes {
 	HostBuffer: HostBuffer;
 }
 
-interface BufferTypes extends ArrayBufferTypes  {
+interface ByteBufferTypes extends ArrayBufferTypes  {
 	Uint8Array: Uint8Array,
 	Uint8ClampedArray: Uint8ClampedArray,
 	Int8Array: Int8Array,
 	DataView: DataView
 }
 
-type BufferLike = BufferTypes[keyof BufferTypes];
+type ByteBuffer = ByteBufferTypes[keyof ByteBufferTypes];
 
 interface ObjectConstructor {
 	freeze<T>(obj: T, freeze?: boolean | number): Readonly<T>;

package/zip.d.ts

@@ -20,7 +20,7 @@
 
 declare module "zip" {
   class Zip {
-    constructor(buffer: BufferLike);
+    constructor(buffer: ByteBuffer);
     file(path: string): import("file").File;
     iterate(path: string): import("file").Iterator;
     map(path: string): HostBuffer;