@mikrojs/native 0.20.1 → 0.21.0-next.20260913195055

package/runtime/internal.d.ts

@@ -62,7 +62,7 @@ declare module 'native:mikro/result' {
 }
 
 declare module 'native:mikro/observable' {
-  export {Observable} from '@mikrojs/native/runtime/observable/types'
+  export {from, Observable, of} from '@mikrojs/native/runtime/observable/types'
 }
 
 declare module 'native:mikro/sys' {
@@ -158,18 +158,6 @@ declare module 'native:mikro/stdio' {
   }
 }
 
-declare module 'native:mikro/pin' {
-  import type {PinError} from '@mikrojs/native/runtime/pin/types'
-  import type {Result} from 'mikro/result'
-  export type PinMode = 0x01 | 0x03 | 0x05
-  export function pinMode(pin: number, value: PinMode): Result<void, PinError>
-  export function digitalWrite(pin: number, value: 0 | 1): Result<void, PinError>
-  export function digitalRead(pin: number): number
-  // attenuation: 0=0dB, 1=2.5dB, 2=6dB, 3=11dB
-  export function analogRead(pin: number, attenuation: number): Result<number, PinError>
-  export function analogReadMillivolts(pin: number, attenuation: number): Result<number, PinError>
-}
-
 declare module 'native:mikro/watchdog' {
   export function feed(): void
 }
@@ -237,66 +225,6 @@ declare module 'native:mikro/http_server' {
   export function respondEnd(id: number): void
   export function getHeader(id: number, name: string): string | undefined
 }
-declare module 'native:mikro/i2c' {
-  import type {I2cError} from '@mikrojs/native/runtime/i2c/types'
-  import type {Result} from 'mikro/result'
-
-  export interface I2cBaseOptions {
-    freq?: number
-    timeout?: number
-  }
-
-  export interface I2cOptionsWithPins extends I2cBaseOptions {
-    sda: number
-    scl: number
-  }
-
-  export type I2cOptions = I2cBaseOptions | I2cOptionsWithPins
-  export declare const I2c: {
-    prototype: I2c
-    new (busNo: 0 | 1, options?: I2cOptions): I2c
-  }
-
-  export interface I2c {
-    begin(): Result<void, I2cError>
-
-    end(): Result<void, I2cError>
-
-    read(address: number, bytes: number): Result<Uint8Array, I2cError>
-
-    write(address: number, data: Uint8Array, stop?: boolean): Result<void, I2cError>
-
-    scan(): Result<Uint8Array, I2cError>
-  }
-}
-declare module 'native:mikro/spi' {
-  import type {SpiError} from '@mikrojs/native/runtime/spi/types'
-  import type {Result} from 'mikro/result'
-
-  export interface SpiOptions {
-    clk: number
-    mosi: number
-    miso?: number
-    cs?: number
-    freq?: number
-    mode?: 0 | 1 | 2 | 3
-  }
-
-  export declare const Spi: {
-    prototype: Spi
-    new (hostNo: 1 | 2, options: SpiOptions): Spi
-  }
-
-  export interface Spi {
-    begin(): Result<void, SpiError>
-
-    end(): Result<void, SpiError>
-
-    transfer(data: Uint8Array): Result<Uint8Array, SpiError>
-
-    write(data: Uint8Array): Result<void, SpiError>
-  }
-}
 
 declare module 'native:mikro/sntp' {
   import type {SntpError} from '@mikrojs/native/runtime/sntp/types'
@@ -338,73 +266,6 @@ declare module 'native:mikro/nvs_kv' {
   export function info(): {entries: number; used: number; total: number; free: number}
 }
 
-declare module 'native:mikro/pwm' {
-  import type {PwmError} from '@mikrojs/native/runtime/pwm/types'
-  import type {Result} from 'mikro/result'
-
-  export declare const Pwm: {
-    prototype: Pwm
-    new (pin: number, freq: number, duty: number): Pwm
-  }
-
-  export interface Pwm {
-    duty(value?: number): Result<number, PwmError>
-    freq(value?: number): Result<number, PwmError>
-    fade(target: number, durationMs: number): Result<Promise<void>, PwmError>
-    end(): Result<void, PwmError>
-  }
-}
-
-declare module 'native:mikro/neopixel' {
-  import type {NeoPixelError} from '@mikrojs/native/runtime/neopixel/types'
-  import type {Result} from 'mikro/result'
-
-  export declare const NeoPixel: {
-    prototype: NeoPixel
-    new (pin: number, numLeds: number, bytesPerLed: number): NeoPixel
-  }
-
-  export interface NeoPixel {
-    setPixel(index: number, r: number, g: number, b: number, w: number): Result<void, NeoPixelError>
-    fill(r: number, g: number, b: number, w: number): Result<void, NeoPixelError>
-    show(): Result<void, NeoPixelError>
-    clear(): Result<void, NeoPixelError>
-    end(): Result<void, NeoPixelError>
-  }
-}
-
-declare module 'native:mikro/uart' {
-  import type {UartError} from '@mikrojs/native/runtime/uart/types'
-  import type {Result} from 'mikro/result'
-
-  export interface UartOptions {
-    tx?: number
-    rx?: number
-    baudRate: number
-  }
-
-  export declare const Uart: {
-    prototype: Uart
-    new (port: number, options: UartOptions): Uart
-  }
-
-  export interface Uart {
-    begin(): Result<void, UartError>
-
-    end(): Result<void, UartError>
-
-    write(data: Uint8Array): Result<void, UartError>
-
-    read(): Result<
-      {
-        next(): Promise<IteratorResult<Result<Uint8Array, UartError>>>
-        return(): Promise<IteratorResult<Result<Uint8Array, UartError>>>
-      },
-      UartError
-    >
-  }
-}
-
 declare module 'native:mikro/ble' {
   import type {BleError} from '@mikrojs/native/runtime/ble/types'
   import type {Result} from 'mikro/result'
@@ -593,37 +454,3 @@ declare module 'native:mikro/ota_client' {
   export const bearer: Ota['bearer']
   export const registry: Ota['registry']
 }
-
-declare module 'native:mikro/i2s' {
-  import type {I2sError, I2sSamples} from '@mikrojs/native/runtime/i2s/types'
-  import type {Result} from 'mikro/result'
-
-  export interface I2sNativeOptions {
-    mode?: 'std' | 'pdm'
-    sampleRate: number
-    bitsPerSample?: 16 | 32
-    channels?: 'mono' | 'stereo'
-    bclk?: number
-    ws?: number
-    clk?: number
-    dout?: number
-    din?: number
-    dmaFrames?: number
-    dmaBuffers?: number
-  }
-
-  export declare const I2s: {
-    prototype: I2s
-    new (port: number, options: I2sNativeOptions): I2s
-  }
-
-  export interface I2s {
-    begin(): Result<void, I2sError>
-
-    end(): Result<void, I2sError>
-
-    write(data: I2sSamples | Uint8Array): Promise<Result<void, I2sError>>
-
-    capture(frames: number, options?: {gainBits?: number}): Result<Int16Array, I2sError>
-  }
-}

package/runtime/kv/shared.ts

@@ -58,18 +58,12 @@ export function makeCreateValue(native: NativeKvFns) {
     const onReadError = options?.onReadError ?? (() => undefined)
 
     function doGet(): unknown {
+      let v: unknown
+      // Only the native read is guarded: a throw from parse() or from the
+      // handler itself is a caller bug, and treating it as corruption would
+      // delete data that read back fine.
       try {
-        const v = native.get(key)
-        if (v === undefined) return hasInitialValue ? initialValue : undefined
-        if (schema) {
-          const result = parse(schema, v)
-          if (!result.ok) {
-            // Schema mismatch: data decoded fine, don't delete it
-            return onReadError(result.error)
-          }
-          return result.value
-        }
-        return v
+        v = native.get(key)
       } catch (e) {
         // TypeError is the native's corruption marker (stored bytes that do
         // not decode): delete and heal. Anything else is a transient read
@@ -83,6 +77,14 @@ export function makeCreateValue(native: NativeKvFns) {
         }
         return onReadError(e)
       }
+      if (v === undefined) return hasInitialValue ? initialValue : undefined
+      if (schema) {
+        const result = parse(schema, v)
+        // Schema mismatch: data decoded fine, don't delete it
+        if (!result.ok) return onReadError(result.error)
+        return result.value
+      }
+      return v
     }
 
     function doSet(value: unknown) {

package/runtime/neopixel/types.ts

@@ -1,19 +1,27 @@
+/* mikro/neopixel, declared here and implemented in C (mik_neopixel.cpp). */
+
+import type {GpioInUse} from '../gpio/types.js'
 import type {Result} from '../result/types.js'
 
 export interface NeoPixelOptions {
-  /** Number of LEDs in the strip */
+  /** Number of LEDs in the strip, 1 to 1024 */
   count: number
   /** Set to true for RGBW strips (SK6812). Defaults to false (RGB/WS2812). */
   rgbw?: boolean
 }
 
 export type NeoPixelError =
-  | {name: 'NotActive'}
+  | GpioInUse
+  | {name: 'InvalidGpio'; message: string}
+  | {name: 'InvalidParam'; message: string}
+  | {name: 'ConfigFailed'; message: string}
   | {name: 'IndexOutOfRange'}
   | {name: 'ShowFailed'; message: string}
 
-export declare class NeoPixel {
-  constructor(pin: number, options: NeoPixelOptions)
+/**
+ * @public
+ */
+export interface NeoPixel {
   /** Set a single pixel's color (0–255 per channel) */
   setPixel(index: number, r: number, g: number, b: number, w?: number): Result<void, NeoPixelError>
   /** Set all pixels to the same color */
@@ -22,6 +30,16 @@ export declare class NeoPixel {
   show(): Result<void, NeoPixelError>
   /** Turn off all pixels and transmit */
   clear(): Result<void, NeoPixelError>
-  /** Release the RMT channel */
-  end(): Result<void, NeoPixelError>
+  /** Releases the RMT channel and the GPIO pin. Calling it again does nothing. Afterwards the other
+   *  methods do nothing and return `ok()`; the first such call prints a warning. */
+  end(): void
 }
+
+/**
+ * Claims a GPIO pin as the data line of a WS2812 or SK6812 LED strip.
+ * @public
+ */
+export declare function NeoPixel(
+  gpio: number,
+  options: NeoPixelOptions,
+): Result<NeoPixel, NeoPixelError>

package/runtime/observable/native-observable.node-shim.ts

@@ -167,7 +167,7 @@ class Subscription {
   }
 }
 
-type SubscribeCallback<T> = (sub: Subscriber<T>) => void
+type SubscribeCallback<T> = (sub: Subscriber<T>) => void | (() => void)
 
 export class Observable<Ok, Err = never> {
   // The shim doesn't actually use `_phantom` at runtime; the type parameters are
@@ -183,15 +183,46 @@ export class Observable<Ok, Err = never> {
   }
 
   subscribe(observer?: unknown): Subscription {
-    if (!dispatchActive) panicked = false
     const sub = new Subscriber<unknown>(observer)
+    this.start(sub)
+    return new Subscription(sub)
+  }
+
+  /* Run the producer against a subscriber built by the caller. */
+  private start(sub: Subscriber<unknown>): void {
+    if (!dispatchActive) panicked = false
+    let teardown: void | (() => void)
     try {
-      this.#cb(sub)
+      teardown = this.#cb(sub)
     } catch (err) {
       sub.closeSilently()
       throw err
     }
-    return new Subscription(sub)
+    /* A returned function is a teardown, as if passed to addTeardown() last. */
+    if (typeof teardown === 'function') sub.addTeardown(teardown)
+  }
+
+  /* For the operators shim, mirroring forward() in mik_observable.cpp: the
+   * upstream subscriber joins `down`'s teardowns before the producer runs, so
+   * a chain that completes during setup already closes it, and a closed
+   * `down` subscribes nothing. */
+  static forward(
+    source: Observable<unknown, unknown>,
+    down: {closed: boolean; addTeardown(fn: () => void): void},
+    observer: unknown,
+  ): void {
+    if (down.closed) return
+    const up = new Subscriber<unknown>(observer)
+    down.addTeardown(() => up.closeSilently())
+    source.start(up)
+  }
+
+  /* Subscribe and hand back a handle the caller closes itself (switchMap's
+   * inner stream, whose lifetime the operator manages). */
+  static start(source: Observable<unknown, unknown>, observer: unknown): {close(): void} {
+    const up = new Subscriber<unknown>(observer)
+    source.start(up)
+    return {close: () => up.closeSilently()}
   }
 
   pipe(...ops: Array<(o: Observable<unknown, unknown>) => Observable<unknown, unknown>>) {
@@ -205,39 +236,6 @@ export class Observable<Ok, Err = never> {
     return current
   }
 
-  static from(src: unknown): Observable<unknown, unknown> {
-    if (src instanceof Observable) return src
-    if (
-      src != null &&
-      (typeof src === 'object' || typeof src === 'function') &&
-      typeof (src as {then?: unknown}).then === 'function'
-    ) {
-      // Promise-shaped
-      return new Observable<unknown>((sub) => {
-        ;(src as PromiseLike<unknown>).then((value) => {
-          if (sub.closed) return
-          sub.next(value)
-          if (sub.closed) return
-          sub.complete()
-        })
-      })
-    }
-    if (
-      src != null &&
-      (typeof src === 'object' || typeof src === 'string') &&
-      typeof (src as {[Symbol.iterator]?: unknown})[Symbol.iterator] === 'function'
-    ) {
-      return new Observable<unknown>((sub) => {
-        for (const value of src as Iterable<unknown>) {
-          if (sub.closed || panicked) return
-          sub.next(value)
-        }
-        if (!sub.closed) sub.complete()
-      })
-    }
-    throw new TypeError('Observable.from: source must be a Promise, Iterable, or Observable')
-  }
-
   static withEmitters<Ok, Err = never>(): {
     observable: Observable<Ok, Err>
     next: (value: unknown) => void
@@ -282,3 +280,41 @@ export class Observable<Ok, Err = never> {
     return {observable: observable as unknown as Observable<Ok, Err>, next, complete}
   }
 }
+
+/* Mirrors the C module exports: from(source) and of(...values). */
+export function from(src: unknown): Observable<unknown, unknown> {
+  if (
+    src != null &&
+    (typeof src === 'object' || typeof src === 'function') &&
+    typeof (src as {then?: unknown}).then === 'function'
+  ) {
+    // Promise-shaped
+    return new Observable<unknown>((sub) => {
+      ;(src as PromiseLike<unknown>).then((value) => {
+        if (sub.closed) return
+        sub.next(value)
+        if (sub.closed) return
+        sub.complete()
+      })
+    })
+  }
+  if (
+    src != null &&
+    (typeof src === 'object' || typeof src === 'string') &&
+    typeof (src as {[Symbol.iterator]?: unknown})[Symbol.iterator] === 'function'
+  ) {
+    return new Observable<unknown>((sub) => {
+      for (const value of src as Iterable<unknown>) {
+        if (sub.closed || panicked) return
+        sub.next(value)
+      }
+      if (!sub.closed) sub.complete()
+    })
+  }
+  throw new TypeError('from: source must be a Promise or an Iterable')
+}
+
+/* of(...values): from() over the argument array. */
+export function of(...values: unknown[]): Observable<unknown, unknown> {
+  return from(values)
+}