@mikrojs/native 0.20.1 → 0.21.0-next.20260913195055

package/runtime/pin/types.ts

@@ -1,49 +0,0 @@
-import type {Result} from '../result/types.js'
-
-export type PinMode = 'INPUT' | 'OUTPUT' | 'INPUT_PULLUP'
-
-/**
- * ADC attenuation setting, controls the measurable voltage range.
- * - `'0db'` — 0–750 mV
- * - `'2.5db'` — 0–1050 mV
- * - `'6db'` — 0–1300 mV
- * - `'11db'` — 0–2500 mV (default)
- */
-export type Attenuation = '0db' | '2.5db' | '6db' | '11db'
-
-export interface AnalogReadOptions {
-  /** ADC attenuation. Defaults to `'11db'` (0–2500 mV range). */
-  attenuation?: Attenuation
-}
-
-export type PinError =
-  | {name: 'InvalidPin'; message: string}
-  | {name: 'SetModeFailed'; message: string}
-  | {name: 'WriteFailed'; message: string}
-  | {name: 'AdcInitFailed'; message: string}
-  | {name: 'AdcReadFailed'; message: string}
-  | {name: 'InvalidAdcPin'}
-
-export declare function pinMode(pin: number, mode: PinMode): Result<void, PinError>
-
-export declare function digitalWrite(pin: number, value: 0 | 1): Result<void, PinError>
-
-export declare function digitalRead(pin: number): 0 | 1
-
-/**
- * Read the raw ADC value from a pin.
- * @returns A Result containing a 12-bit integer (0–4095) proportional to the input voltage, or a PinError.
- */
-export declare function analogRead(
-  pin: number,
-  options?: AnalogReadOptions,
-): Result<number, PinError>
-
-/**
- * Read a calibrated voltage from a pin.
- * @returns A Result containing the input voltage in millivolts, or a PinError.
- */
-export declare function analogReadMillivolts(
-  pin: number,
-  options?: AnalogReadOptions,
-): Result<number, PinError>

package/runtime/pwm/pwm.ts

@@ -1,32 +0,0 @@
-import {ok} from 'mikro/result'
-import {Pwm as NativePwm} from 'native:mikro/pwm'
-
-import type {Result} from '../result/types.js'
-import type {PwmError, PwmOptions} from './types.js'
-
-export class Pwm {
-  #native: InstanceType<typeof NativePwm>
-
-  constructor(pin: number, options: PwmOptions) {
-    this.#native = new NativePwm(pin, options.freq, options.duty ?? 0)
-  }
-
-  duty(value?: number): Result<number, PwmError> {
-    return this.#native.duty(value)
-  }
-
-  freq(value?: number): Result<number, PwmError> {
-    return this.#native.freq(value)
-  }
-
-  async fade(targetDuty: number, durationMs: number): Promise<Result<void, PwmError>> {
-    const result = this.#native.fade(targetDuty, durationMs)
-    if (!result.ok) return result
-    await result.value
-    return ok(undefined)
-  }
-
-  end(): Result<void, PwmError> {
-    return this.#native.end()
-  }
-}

package/runtime/spi/spi.ts

@@ -1,31 +0,0 @@
-import * as native from 'native:mikro/spi'
-
-import type {Result} from '../result/types.js'
-import type {Spi as PlatformSpi, SpiError, SpiOptions} from './types.js'
-
-/**
- * @public
- */
-export class Spi implements PlatformSpi {
-  #native: native.Spi
-
-  constructor(hostNo: 1 | 2, options: SpiOptions) {
-    this.#native = new native.Spi(hostNo, options)
-  }
-
-  begin(): Result<void, SpiError> {
-    return this.#native.begin()
-  }
-
-  end(): Result<void, SpiError> {
-    return this.#native.end()
-  }
-
-  transfer(data: Uint8Array): Result<Uint8Array, SpiError> {
-    return this.#native.transfer(data)
-  }
-
-  write(data: Uint8Array): Result<void, SpiError> {
-    return this.#native.write(data)
-  }
-}

package/runtime/uart/uart.ts

@@ -1,52 +0,0 @@
-import {ok} from 'mikro/result'
-import * as native from 'native:mikro/uart'
-
-import type {Result} from '../result/types.js'
-import type {
-  UartBase,
-  UartBaseOptions,
-  UartError,
-  UartRxOnlyOptions,
-  UartTxOnlyOptions,
-  UartTxRxOptions,
-} from './types.js'
-
-/**
- * @public
- */
-export class Uart implements UartBase {
-  #native: native.Uart
-
-  constructor(port: number, options: UartTxRxOptions)
-  constructor(port: number, options: UartTxOnlyOptions)
-  constructor(port: number, options: UartRxOnlyOptions)
-  constructor(port: number, options: UartBaseOptions & {tx?: number; rx?: number}) {
-    this.#native = new native.Uart(port, options)
-  }
-
-  begin(): Result<void, UartError> {
-    return this.#native.begin()
-  }
-
-  end(): Result<void, UartError> {
-    return this.#native.end()
-  }
-
-  write(data: Uint8Array): Result<void, UartError> {
-    return this.#native.write(data)
-  }
-
-  read(): Result<AsyncIterable<Result<Uint8Array, UartError>>, UartError> {
-    const result = this.#native.read()
-    if (!result.ok) return result
-    const nativeIter = result.value
-    // Wrap the native iterator object (which has next/return) into a proper AsyncIterable.
-    // Native yields Result items directly via mik__result_ok / mik__result_err_tag.
-    const iterable: AsyncIterable<Result<Uint8Array, UartError>> = {
-      [Symbol.asyncIterator]() {
-        return nativeIter as AsyncIterator<Result<Uint8Array, UartError>>
-      },
-    }
-    return ok(iterable)
-  }
-}