effect-web-midi 0.1.0

package/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.ts

@@ -0,0 +1,110 @@
+import type * as Brand from 'effect/Brand'
+import * as Effect from 'effect/Effect'
+import * as EFunction from 'effect/Function'
+import * as Option from 'effect/Option'
+import * as Record from 'effect/Record'
+import * as EMIDIAccess from '../../EMIDIAccess.ts'
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import * as Errors from '../../errors.ts'
+import type * as Util from '../../util.ts'
+import * as Get from './getMutablePortPropertyByPort.ts'
+
+const getPortByIdGeneric2 =
+  // biome-ignore lint/suspicious/noExplicitAny: I don't care
+    <T extends Record.ReadonlyRecord<string & Brand.Brand<'MIDIPortId'>, any>>(
+      getPortMap: <E = never, R = never>(
+        polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+      ) => Effect.Effect<T, E, R>,
+    ) =>
+    <A, E2, R2, TE = never, TR = never>(
+      polymorphicAccess: Util.PolymorphicEffect<
+        EMIDIAccess.EMIDIAccessInstance,
+        TE,
+        TR
+      >,
+      transformPortEffect: (
+        effect: Effect.Effect<
+          T[Extract<keyof T, string & Brand.Brand<'MIDIPortId'>>],
+          TE | Errors.PortNotFoundError,
+          TR
+        >,
+      ) => Effect.Effect<A, E2, R2>,
+      portId: Extract<keyof T, EMIDIPort.BothId>,
+    ) =>
+      EFunction.pipe(
+        getPortMap(polymorphicAccess),
+        Effect.flatMap(
+          EFunction.flow(
+            Record.get(portId),
+            Option.match({
+              onNone: () => new Errors.PortNotFoundError({ portId }),
+              onSome: e => Effect.succeed(e),
+            }),
+          ),
+        ),
+        transformPortEffect,
+      )
+
+// TODO: Check if software synth devices access is present. Having desired
+// port absent in the record doesn't guarantee it's disconnected
+
+/**
+ *
+ *
+ */
+export const getPortDeviceStateByPortIdAndAccess = <TE = never, TR = never>(
+  polymorphicAccess: Util.PolymorphicEffect<
+    EMIDIAccess.EMIDIAccessInstance,
+    TE,
+    TR
+  >,
+  id: EMIDIPort.BothId,
+) =>
+  getPortByIdGeneric2(EMIDIAccess.getAllPortsRecord)(
+    polymorphicAccess,
+    EFunction.flow(
+      Get.getPortDeviceStateByPort,
+      Effect.catchTag('PortNotFound', () =>
+        Effect.succeed('disconnected' as const),
+      ),
+    ),
+    id,
+  )
+
+/**
+ *
+ *
+ */
+export const getPortConnectionStateByPortIdAndAccess = <TE = never, TR = never>(
+  polymorphicAccess: Util.PolymorphicEffect<
+    EMIDIAccess.EMIDIAccessInstance,
+    TE,
+    TR
+  >,
+  id: EMIDIPort.BothId,
+) =>
+  getPortByIdGeneric2(EMIDIAccess.getAllPortsRecord)(
+    polymorphicAccess,
+    Get.getPortConnectionStateByPort,
+    id,
+  )
+
+// TODO: getInputConnectionStateByPortIdAndAccess
+export const getInputConnectionStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: getInputDeviceStateByPortIdAndAccess
+export const getInputDeviceStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: getOutputConnectionStateByPortIdAndAccess
+export const getOutputConnectionStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: getOutputDeviceStateByPortIdAndAccess
+export const getOutputDeviceStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}

package/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.ts

@@ -0,0 +1,37 @@
+import * as EMIDIAccess from '../../EMIDIAccess.ts'
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import * as Get from './getMutablePortPropertyByPortIdAndAccess.ts'
+
+/**
+ *
+ *
+ */
+export const getPortDeviceStateByPortId = (id: EMIDIPort.BothId) =>
+  Get.getPortDeviceStateByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+/**
+ *
+ *
+ */
+export const getPortConnectionStateByPortId = (id: EMIDIPort.BothId) =>
+  Get.getPortConnectionStateByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+// TODO: getInputConnectionStateByPortId
+export const getInputConnectionStateByPortId = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: getInputDeviceStateByPortId
+export const getInputDeviceStateByPortId = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: getOutputConnectionStateByPortId
+export const getOutputConnectionStateByPortId = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: getOutputDeviceStateByPortId
+export const getOutputDeviceStateByPortId = () => {
+  throw new Error('not implemented')
+}

package/src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.ts

@@ -0,0 +1,12 @@
+import * as EMIDIPort from '../EMIDIPort.ts'
+import type { MIDIPortMutableProperty } from './matchMutablePortProperty/matchMutablePortPropertyByPort.ts'
+
+/**
+ * @internal
+ */
+export const getValueInRawPortFieldUnsafe =
+  <const TMIDIPortMutableProperty extends MIDIPortMutableProperty>(
+    property: TMIDIPortMutableProperty,
+  ) =>
+  (port: EMIDIPort.EMIDIPort) =>
+    EMIDIPort.assumeImpl(port)._port[property]

package/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.ts

@@ -0,0 +1,183 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import * as Effect from 'effect/Effect'
+import * as EFunction from 'effect/Function'
+import * as Record from 'effect/Record'
+import * as EMIDIInput from '../../EMIDIInput.ts'
+import * as EMIDIOutput from '../../EMIDIOutput.ts'
+import * as EMIDIPort from '../../EMIDIPort.ts'
+import * as Util from '../../util.ts'
+import * as Get from '../getValueInRawPortFieldUnsafe.ts'
+
+/**
+ * @internal
+ */
+const matchMutableMIDIPortProperty = <
+  const TMIDIPortProperty extends MIDIPortMutableProperty,
+  THighLevelPortType extends MIDIPortType,
+>(
+  property: TMIDIPortProperty,
+  is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>,
+): DualMatchPortState<THighLevelPortType, TMIDIPortProperty> =>
+  EFunction.dual<
+    MatchStatePortLast<THighLevelPortType, TMIDIPortProperty>,
+    MatchStatePortFirst<THighLevelPortType, TMIDIPortProperty>
+  >(
+    Util.polymorphicCheckInDual(is),
+    Effect.fn(function* (polymorphicPort, config) {
+      const port = yield* Util.fromPolymorphic(
+        polymorphicPort,
+        is as (
+          port: unknown,
+        ) => port is EMIDIPort.EMIDIPort<THighLevelPortType>,
+      )
+
+      const state = Get.getValueInRawPortFieldUnsafe(property)(port)
+
+      for (const [stateCase, stateCallback] of Record.toEntries(config))
+        if (state === stateCase)
+          return (stateCallback as PortStateHandler)(port)
+
+      return yield* Effect.dieMessage(
+        `AssertionFailed: Missing handler for "${state}" state inside "${property}" property`,
+      )
+    }),
+  )
+
+/**
+ *
+ */
+export const matchPortConnectionStateByPort = matchMutableMIDIPortProperty(
+  'connection',
+  EMIDIPort.is,
+)
+
+/**
+ *
+ */
+export const matchPortDeviceStateByPort = matchMutableMIDIPortProperty(
+  'state',
+  EMIDIPort.is,
+)
+
+/**
+ *
+ */
+export const matchInputConnectionStateByPort = matchMutableMIDIPortProperty(
+  'connection',
+  EMIDIInput.is,
+)
+
+/**
+ *
+ */
+export const matchInputDeviceStateByPort = matchMutableMIDIPortProperty(
+  'state',
+  EMIDIInput.is,
+)
+
+/**
+ *
+ */
+export const matchOutputConnectionStateByPort = matchMutableMIDIPortProperty(
+  'connection',
+  EMIDIOutput.is,
+)
+
+/**
+ *
+ */
+export const matchOutputDeviceStateByPort = matchMutableMIDIPortProperty(
+  'state',
+  EMIDIOutput.is,
+)
+
+export type MIDIPortMutableProperty = 'state' | 'connection'
+
+export interface PortStateHandler {
+  // biome-ignore lint/suspicious/noExplicitAny: <There's no better way to type>
+  (port: EMIDIPort.EMIDIPort): any
+}
+export interface MatcherConfigPlain extends Record<string, PortStateHandler> {}
+
+export interface MatchResult<TActualConf extends MatcherConfigPlain, E, R>
+  extends Effect.Effect<ReturnType<TActualConf[keyof TActualConf]>, E, R> {}
+
+export interface DualMatchPortState<
+  THighLevelPortType extends MIDIPortType,
+  TMIDIPortProperty extends MIDIPortMutableProperty,
+> extends MatchStatePortLast<THighLevelPortType, TMIDIPortProperty>,
+    MatchStatePortFirst<THighLevelPortType, TMIDIPortProperty> {}
+
+export interface MatchStatePortFirst<
+  THighLevelPortType extends MIDIPortType,
+  TMIDIPortProperty extends MIDIPortMutableProperty,
+> {
+  /**
+   * Description placeholder
+   *
+   * @param polymorphicPort
+   * @param stateCaseToHandlerMap
+   * @returns
+   */
+  <
+    TStateCaseToHandlerMap extends StateCaseToHandlerMap<
+      TMIDIPortProperty,
+      THighLevelPortType,
+      TStateCaseToHandlerMap
+    >,
+    E = never,
+    R = never,
+  >(
+    polymorphicPort: EMIDIPort.PolymorphicPort<E, R, THighLevelPortType>,
+    stateCaseToHandlerMap: TStateCaseToHandlerMap,
+  ): MatchResult<TStateCaseToHandlerMap, E, R>
+}
+
+export interface MatchStatePortLast<
+  THighLevelPortType extends MIDIPortType,
+  TMIDIPortProperty extends MIDIPortMutableProperty,
+> {
+  /**
+   * Description placeholder
+   *
+   * @param stateCaseToHandlerMap
+   * @returns
+   */
+  <
+    TStateCaseToHandlerMap extends StateCaseToHandlerMap<
+      TMIDIPortProperty,
+      THighLevelPortType,
+      TStateCaseToHandlerMap
+    >,
+  >(
+    stateCaseToHandlerMap: TStateCaseToHandlerMap,
+  ): {
+    /**
+     * Description placeholder
+     *
+     * @param polymorphicPort
+     * @returns
+     */
+    <E = never, R = never>(
+      polymorphicPort: EMIDIPort.PolymorphicPort<E, R, THighLevelPortType>,
+    ): MatchResult<TStateCaseToHandlerMap, E, R>
+  }
+}
+
+export type StateCaseToHandlerMap<
+  TMIDIPortProperty extends MIDIPortMutableProperty,
+  TMIDIPortType extends MIDIPortType,
+  TConfigSelf,
+> = {
+  readonly [StateCase in MIDIPort[TMIDIPortProperty]]: (
+    port: EMIDIPort.EMIDIPort<TMIDIPortType>,
+    // biome-ignore lint/suspicious/noExplicitAny: <There's no preciser type>
+  ) => any
+} & {
+  readonly [RedundantValueCaseHandling in Exclude<
+    keyof TConfigSelf,
+    MIDIPort[TMIDIPortProperty]
+  >]: never
+}

package/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.ts

@@ -0,0 +1,29 @@
+// TODO: matchInputConnectionStateByPortIdAndAccess
+export const matchInputConnectionStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: matchInputDeviceStateByPortIdAndAccess
+export const matchInputDeviceStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: matchOutputConnectionStateByPortIdAndAccess
+export const matchOutputConnectionStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: matchOutputDeviceStateByPortIdAndAccess
+export const matchOutputDeviceStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: matchPortConnectionStateByPortIdAndAccess
+export const matchPortConnectionStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: matchPortDeviceStateByPortIdAndAccess
+export const matchPortDeviceStateByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}

package/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.ts

@@ -0,0 +1,86 @@
+import type * as Effect from 'effect/Effect'
+import type * as EMIDIAccess from '../../EMIDIAccess.ts'
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import type * as Errors from '../../errors.ts'
+import * as Get from '../../getPortByPortId/getPortByPortIdInContext.ts'
+import * as Match from './matchMutablePortPropertyByPort.ts'
+
+/**
+ * @internal
+ */
+const makeMatcherTakingPortIds =
+  <
+    THighLevelPortType extends MIDIPortType,
+    TMIDIPortProperty extends Match.MIDIPortMutableProperty,
+  >(
+    match: Match.DualMatchPortState<THighLevelPortType, TMIDIPortProperty>,
+    getPort: (
+      id: EMIDIPort.Id<THighLevelPortType>,
+    ) => Effect.Effect<
+      EMIDIPort.EMIDIPort<NoInfer<THighLevelPortType>>,
+      Errors.PortNotFoundError,
+      EMIDIAccess.EMIDIAccess
+    >,
+  ) =>
+  <
+    TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<
+      TMIDIPortProperty,
+      THighLevelPortType,
+      TStateCaseToHandlerMap
+    >,
+  >(
+    id: EMIDIPort.Id<THighLevelPortType>,
+    stateCaseToHandlerMap: TStateCaseToHandlerMap,
+  ) =>
+    match(getPort(id), stateCaseToHandlerMap)
+
+/**
+ *
+ */
+export const matchPortConnectionStateByPortIdInContext =
+  makeMatcherTakingPortIds(
+    Match.matchPortConnectionStateByPort,
+    Get.getPortByPortIdInContext,
+  )
+
+/**
+ *
+ */
+export const matchInputConnectionStateByPortIdInContext =
+  makeMatcherTakingPortIds(
+    Match.matchInputConnectionStateByPort,
+    Get.getInputByPortIdInContext,
+  )
+
+/**
+ *
+ */
+export const matchOutputConnectionStateByPortIdInContext =
+  makeMatcherTakingPortIds(
+    Match.matchOutputConnectionStateByPort,
+    Get.getOutputByPortIdInContext,
+  )
+
+/**
+ *
+ */
+export const matchPortDeviceStateByPortIdInContext = makeMatcherTakingPortIds(
+  Match.matchPortDeviceStateByPort,
+  Get.getPortByPortIdInContext,
+)
+
+/**
+ *
+ */
+export const matchInputDeviceStateByPortIdInContext = makeMatcherTakingPortIds(
+  Match.matchInputDeviceStateByPort,
+  Get.getInputByPortIdInContext,
+)
+
+/**
+ *
+ */
+export const matchOutputDeviceStateByPortIdInContext = makeMatcherTakingPortIds(
+  Match.matchOutputDeviceStateByPort,
+  Get.getOutputByPortIdInContext,
+)

package/src/internal/parsing.ts

@@ -0,0 +1,219 @@
+/**
+ * @file This module is not for general use, these are just helpers to test the
+ * MIDI API with the only MIDI device I have: nanoPAD v1
+ */
+
+import * as Stream from 'effect/Stream'
+
+//? NOTE: Look at the issue https://github.com/WebAudio/web-midi-api/issues/179
+// which discusses higher-level MIDI message access
+
+/**
+ *
+ * @param self
+ * @returns
+ */
+export const withParsedDataField = <
+  A extends { readonly midiMessage: Uint8Array<ArrayBuffer> },
+  E,
+  R,
+>(
+  self: Stream.Stream<A, E, R>,
+) =>
+  Stream.map(self, ({ midiMessage, ...obj }) => ({
+    ...obj,
+    midiMessage: dataEntryParser(midiMessage),
+  })) as Stream.Stream<
+    Omit<A, 'midiMessage'> & { readonly midiMessage: ParsedMIDIMessages },
+    E,
+    R
+  >
+
+/**
+ *
+ * @param self
+ * @returns
+ */
+export const withTouchpadPositionUpdates = <
+  A extends {
+    midiMessage:
+      | ControlChange
+      | TouchpadRelease
+      | PitchBendChange
+      | { _tag: string & {} }
+  },
+  E,
+  R,
+>(
+  self: Stream.Stream<A, E, R>,
+): Stream.Stream<
+  | A
+  | (Omit<A, 'midiMessage'> & { readonly midiMessage: TouchpadPositionUpdate }),
+  E,
+  R
+> =>
+  Stream.mapAccum(
+    self,
+    { x: 0, y: 0, seenPressedTouchpadEventsInARow: 0 },
+    (ctx, current) => {
+      const { midiMessage, ...rest } = current
+      const select = <T>(control: T, pitch: T, previous: T) =>
+        ({
+          'Control Change': control,
+          'Pitch Bend Change': pitch,
+          'Touchpad Release': 0, // resets everything
+        })[midiMessage._tag as string] ?? previous
+
+      const position = {
+        x: select(ctx.x, (midiMessage as PitchBendChange).value, ctx.x),
+        y: select((midiMessage as ControlChange).value, ctx.y, ctx.y),
+      }
+
+      const seenPressedTouchpadEventsInARow = select(
+        ctx.seenPressedTouchpadEventsInARow + 1,
+        ctx.seenPressedTouchpadEventsInARow + 1,
+        ctx.seenPressedTouchpadEventsInARow,
+      )
+
+      return [
+        { ...position, seenPressedTouchpadEventsInARow },
+        seenPressedTouchpadEventsInARow > 1 &&
+        (position.x !== ctx.x || position.y !== ctx.y)
+          ? Stream.make(current, {
+              ...rest,
+              midiMessage: {
+                _tag: 'Touchpad Position Update' as const,
+                ...position,
+              } satisfies TouchpadPositionUpdate,
+            })
+          : Stream.succeed(current),
+      ]
+    },
+  ).pipe(Stream.flatten())
+
+export type ParsedMIDIMessages =
+  | NoteRelease
+  | NotePress
+  | UnknownReply
+  | ControlChange
+  | TouchpadRelease
+  | PitchBendChange
+
+function dataEntryParser(
+  midiMessage: Uint8Array<ArrayBuffer>,
+): ParsedMIDIMessages {
+  const unknown = () => {
+    let stack = ''
+    if (
+      'stackTraceLimit' in Error &&
+      'captureStackTrace' in Error &&
+      typeof Error.captureStackTrace === 'function'
+    ) {
+      const { stackTraceLimit } = Error
+      Error.stackTraceLimit = 4
+      const stackHolder = {} as { stack: string }
+      Error.captureStackTrace(stackHolder)
+      Error.stackTraceLimit = stackTraceLimit
+      stack = stackHolder.stack ?? new Error().stack ?? ''
+    }
+    const result = {
+      _tag: 'Unknown Reply' as const,
+      unexpectedData: midiMessage.toString(),
+      stack,
+    }
+    return result
+  }
+  if (midiMessage.length !== 3) return unknown()
+  const first = midiMessage.at(0)
+  if (first === undefined) return unknown()
+
+  const second = midiMessage.at(1)
+  if (second === undefined) return unknown()
+
+  const third = midiMessage.at(2)
+  if (third === undefined) return unknown()
+
+  const code = first >> 4
+  const channel = first & 0b1111
+
+  if (code === 0x8) {
+    if (third !== 0x40) return unknown()
+    return {
+      _tag: 'Note Release',
+      channel,
+      note: second,
+    }
+  }
+
+  if (code === 0x9) {
+    if (third === 0) return unknown()
+    return {
+      _tag: 'Note Press',
+      channel,
+      note: second,
+      velocity: third,
+    }
+  }
+
+  if (code === 0xb) {
+    return {
+      _tag: 'Control Change',
+      channel,
+      control: second,
+      value: third,
+    }
+  }
+
+  if (code === 0xe) {
+    if (second === 0 && third === 0x40)
+      return { _tag: 'Touchpad Release', channel }
+
+    if (second === third)
+      return { _tag: 'Pitch Bend Change', channel, value: second }
+    return unknown()
+  }
+  return unknown()
+}
+
+export interface NoteRelease
+  extends Readonly<{ _tag: 'Note Release'; channel: number; note: number }> {}
+
+export interface NotePress
+  extends Readonly<{
+    _tag: 'Note Press'
+    channel: number
+    note: number
+    velocity: number
+  }> {}
+
+export interface UnknownReply
+  extends Readonly<{
+    _tag: 'Unknown Reply'
+    unexpectedData: string
+    stack: string
+  }> {}
+
+export interface ControlChange
+  extends Readonly<{
+    _tag: 'Control Change'
+    channel: number
+    control: number
+    value: number
+  }> {}
+
+export interface TouchpadRelease
+  extends Readonly<{ _tag: 'Touchpad Release'; channel: number }> {}
+
+export interface PitchBendChange
+  extends Readonly<{
+    _tag: 'Pitch Bend Change'
+    channel: number
+    value: number
+  }> {}
+
+export interface TouchpadPositionUpdate
+  extends Readonly<{
+    _tag: 'Touchpad Position Update'
+    x: number
+    y: number
+  }> {}