effect-web-midi 0.2.3

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

@@ -0,0 +1,64 @@
+import * as Effect from 'effect/Effect'
+
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import { getValueInRawPortFieldUnsafe } from '../getValueInRawPortFieldUnsafe.ts'
+import type * as Match from '../matchMutablePortProperty/matchMutablePortPropertyByPort.ts'
+
+/**
+ * @internal
+ */
+const getMutableProperty =
+  <TMIDIPortType extends MIDIPortType>() =>
+  <const TMIDIPortMutableProperty extends Match.MIDIPortMutableProperty>(
+    property: TMIDIPortMutableProperty,
+  ) =>
+  <E = never, R = never>(
+    polymorphicPort: EMIDIPort.PolymorphicPort<E, R, TMIDIPortType>,
+  ) =>
+    Effect.isEffect(polymorphicPort)
+      ? Effect.map(polymorphicPort, getValueInRawPortFieldUnsafe(property))
+      : Effect.sync(() =>
+          getValueInRawPortFieldUnsafe(property)(polymorphicPort),
+        )
+
+/**
+ * @returns A state of the hardware connection between the OS and the device
+ * ({@linkcode MIDIPortDeviceState}). Because it can change over time, it's
+ * wrapped in effect. It's taken from the {@linkcode MIDIPort.state|state}
+ * read-only property of the {@linkcode MIDIPort} interface ([MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIPort/state)).
+ */
+export const getPortDeviceStateByPort = getMutableProperty()('state')
+
+/**
+ * @returns A state of the connection between the browser's tab and OS
+ * abstraction of the device ({@linkcode MIDIPortConnectionState}). Because it
+ * can change over time, it's wrapped in effect. It's taken from the
+ * {@linkcode MIDIPort.connection|connection} read-only property of the
+ * {@linkcode MIDIPort} interface ([MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIPort/connection)).
+ */
+export const getPortConnectionStateByPort = getMutableProperty()('connection')
+
+/**
+ *
+ */
+export const getInputDeviceStateByPort = getMutableProperty<'input'>()('state')
+
+/**
+ *
+ */
+export const getInputConnectionStateByPort =
+  getMutableProperty<'input'>()('connection')
+
+/**
+ *
+ */
+export const getOutputDeviceStateByPort =
+  getMutableProperty<'output'>()('state')
+
+/**
+ *
+ */
+export const getOutputConnectionStateByPort =
+  getMutableProperty<'output'>()('connection')

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

@@ -0,0 +1,114 @@
+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 EMIDIInput from '../../EMIDIInput.ts'
+import type * as EMIDIOutput from '../../EMIDIOutput.ts'
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import * as MIDIErrors from '../../MIDIErrors.ts'
+import * as Get from './getMutablePortPropertyByPort.ts'
+
+/**
+ * @internal
+ */
+const getPortByIdGeneric2 =
+  <T extends Record.ReadonlyRecord<Brand.Branded<string, 'MIDIPortId'>, any>>(
+    getPortMap: <E = never, R = never>(
+      polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+    ) => Effect.Effect<T, E, R>,
+  ) =>
+  <A, E2, R2, E = never, R = never>(
+    polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+    transformPortEffect: (
+      effect: Effect.Effect<
+        T[Extract<keyof T, Brand.Branded<string, 'MIDIPortId'>>],
+        E | MIDIErrors.PortNotFoundError,
+        R
+      >,
+    ) => 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 MIDIErrors.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 = <E = never, R = never>(
+  polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  id: EMIDIPort.BothId,
+) =>
+  getPortByIdGeneric2(EMIDIAccess.getAllPortsRecord)(
+    polymorphicAccess,
+    EFunction.flow(
+      Get.getPortDeviceStateByPort,
+      Effect.catchTag('PortNotFound', () =>
+        Effect.succeed('disconnected' as const),
+      ),
+    ),
+    id,
+  )
+
+/**
+ *
+ *
+ */
+export const getPortConnectionStateByPortIdAndAccess = <E = never, R = never>(
+  polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  id: EMIDIPort.BothId,
+) =>
+  getPortByIdGeneric2(EMIDIAccess.getAllPortsRecord)(
+    polymorphicAccess,
+    Get.getPortConnectionStateByPort,
+    id,
+  )
+
+// TODO: getInputConnectionStateByPortIdAndAccess
+export const getInputConnectionStateByPortIdAndAccess = <E = never, R = never>(
+  _polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  _id: EMIDIInput.Id,
+) => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: getInputDeviceStateByPortIdAndAccess
+export const getInputDeviceStateByPortIdAndAccess = <E = never, R = never>(
+  _polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  _id: EMIDIInput.Id,
+) => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: getOutputConnectionStateByPortIdAndAccess
+export const getOutputConnectionStateByPortIdAndAccess = <E = never, R = never>(
+  _polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  _id: EMIDIOutput.Id,
+) => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: getOutputDeviceStateByPortIdAndAccess
+export const getOutputDeviceStateByPortIdAndAccess = <E = never, R = never>(
+  _polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  _id: EMIDIOutput.Id,
+) => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}

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

@@ -0,0 +1,47 @@
+import * as EMIDIAccess from '../../EMIDIAccess.ts'
+import type * as EMIDIInput from '../../EMIDIInput.ts'
+import type * as EMIDIOutput from '../../EMIDIOutput.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)
+
+/**
+ *
+ *
+ */
+export const getInputDeviceStateByPortId = (id: EMIDIInput.Id) =>
+  Get.getInputDeviceStateByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+/**
+ *
+ *
+ */
+export const getInputConnectionStateByPortId = (id: EMIDIInput.Id) =>
+  Get.getInputConnectionStateByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+/**
+ *
+ *
+ */
+export const getOutputDeviceStateByPortId = (id: EMIDIOutput.Id) =>
+  Get.getOutputDeviceStateByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+/**
+ *
+ *
+ */
+export const getOutputConnectionStateByPortId = (id: EMIDIOutput.Id) =>
+  Get.getOutputConnectionStateByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)

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,182 @@
+/** 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 {
+  (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>,
+  ) => 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 😿  YET!! 🤩')
+}
+
+// TODO: matchInputDeviceStateByPortIdAndAccess
+export const matchInputDeviceStateByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: matchOutputConnectionStateByPortIdAndAccess
+export const matchOutputConnectionStateByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: matchOutputDeviceStateByPortIdAndAccess
+export const matchOutputDeviceStateByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: matchPortConnectionStateByPortIdAndAccess
+export const matchPortConnectionStateByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: matchPortDeviceStateByPortIdAndAccess
+export const matchPortDeviceStateByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}

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

@@ -0,0 +1,87 @@
+import type * as Effect from 'effect/Effect'
+
+import type * as EMIDIAccess from '../../EMIDIAccess.ts'
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import * as Get from '../../getPortByPortId/getPortByPortIdInContext.ts'
+import type * as MIDIErrors from '../../MIDIErrors.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>>,
+      MIDIErrors.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,
+)