effect-web-midi 0.1.0

package/src/internal/getPortByPortId/getPortByPortIdAndAccess.ts

@@ -0,0 +1,116 @@
+/** 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 EMIDIAccess from '../EMIDIAccess.ts'
+import * as EMIDIInput from '../EMIDIInput.ts'
+import * as EMIDIOutput from '../EMIDIOutput.ts'
+import type * as EMIDIPort from '../EMIDIPort.ts'
+import * as Errors from '../errors.ts'
+
+/**
+ *
+ * @internal
+ */
+const getPortByIdAndRemap = <
+  EInput,
+  EOutput,
+  RInput,
+  ROutput,
+  AInputType extends 'input' = never,
+  AOutputType extends 'output' = never,
+>(handlers: {
+  onInputFound: (
+    rawInput: MIDIInput,
+  ) => Effect.Effect<EMIDIPort.EMIDIPort<AInputType>, EInput, RInput>
+  onOutputFound: (
+    rawOutput: MIDIOutput,
+  ) => Effect.Effect<EMIDIPort.EMIDIPort<AOutputType>, EOutput, ROutput>
+}): GetPortById<
+  AInputType | AOutputType,
+  AInputType | AOutputType,
+  never,
+  never,
+  Errors.PortNotFoundError | EInput | EOutput,
+  RInput | ROutput
+> =>
+  EFunction.dual(2, (polymorphicAccess, portId) =>
+    Effect.flatMap(EMIDIAccess.resolve(polymorphicAccess), e => {
+      const rawAccess = EMIDIAccess.assumeImpl(e)._access
+
+      let rawPort: MIDIOutput | MIDIInput | undefined =
+        rawAccess.inputs.get(portId)
+
+      if (rawPort) return handlers.onInputFound(rawPort)
+
+      rawPort = rawAccess.outputs.get(portId)
+
+      if (rawPort) return handlers.onOutputFound(rawPort)
+
+      return new Errors.PortNotFoundError({
+        portId,
+      }) as EMIDIAccess.AcquiredThing<
+        EMIDIPort.EMIDIPort<AInputType | AOutputType>,
+        never,
+        never,
+        never,
+        never,
+        Errors.PortNotFoundError | EInput | EOutput,
+        RInput | ROutput
+      >
+    }),
+  )
+
+/**
+ *
+ * If you want to ensure the type of returned port match the type of ID, use
+ * type-specific getters {@linkcode getInputByPortIdAndAccess} and
+ * {@linkcode getOutputByPortIdAndAccess}, because in runtime, these branded
+ * port IDs passed as function arguments, are just strings and cannot ensure
+ * soundness
+ */
+export const getPortByPortIdAndAccess = getPortByIdAndRemap({
+  onInputFound: EFunction.flow(EMIDIInput.make, Effect.succeed),
+  onOutputFound: EFunction.flow(EMIDIOutput.make, Effect.succeed),
+})
+
+/**
+ *
+ *
+ */
+export const getInputByPortIdAndAccess = getPortByIdAndRemap({
+  onInputFound: EFunction.flow(EMIDIInput.make, Effect.succeed),
+  onOutputFound: rawOutput =>
+    Effect.dieMessage(
+      `Assertion failed: getInputById found output port with the id=${rawOutput.id}`,
+    ),
+})
+
+/**
+ *
+ *
+ */
+export const getOutputByPortIdAndAccess = getPortByIdAndRemap({
+  onInputFound: rawInput =>
+    Effect.dieMessage(
+      `Assertion failed: getOutputById found output port with the id=${rawInput.id}`,
+    ),
+  onOutputFound: EFunction.flow(EMIDIOutput.make, Effect.succeed),
+})
+
+export interface GetPortById<
+  TReturnedPortType extends TTypeOfPortId,
+  TTypeOfPortId extends MIDIPortType,
+  TAccessGettingFallbackError,
+  TAccessGettingFallbackRequirement,
+  TAdditionalError,
+  TAdditionalRequirement,
+> extends EMIDIAccess.GetThingByPortId<
+    EMIDIPort.EMIDIPort<TReturnedPortType>,
+    TTypeOfPortId,
+    TAccessGettingFallbackError,
+    TAccessGettingFallbackRequirement,
+    TAdditionalError | Errors.PortNotFoundError,
+    TAdditionalRequirement
+  > {}

package/src/internal/getPortByPortId/getPortByPortIdInContext.ts

@@ -0,0 +1,26 @@
+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 './getPortByPortIdAndAccess.ts'
+
+/**
+ *
+ *
+ */
+export const getPortByPortIdInContext = (id: EMIDIPort.BothId) =>
+  Get.getPortByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+/**
+ *
+ *
+ */
+export const getInputByPortIdInContext = (id: EMIDIInput.Id) =>
+  Get.getInputByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)
+
+/**
+ *
+ *
+ */
+export const getOutputByPortIdInContext = (id: EMIDIOutput.Id) =>
+  Get.getOutputByPortIdAndAccess(EMIDIAccess.EMIDIAccess, id)

package/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPort.ts

@@ -0,0 +1,148 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import * as EMIDIInput from '../EMIDIInput.ts'
+import * as EMIDIOutput from '../EMIDIOutput.ts'
+import * as EMIDIPort from '../EMIDIPort.ts'
+import * as StreamMaker from '../StreamMaker.ts'
+import * as Util from '../util.ts'
+
+/**
+ *
+ * @internal
+ */
+const makePortStateChangesStreamFactory = <
+  THighLevelPortType extends MIDIPortType,
+>(
+  is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>,
+) =>
+  StreamMaker.createStreamMakerFrom<MIDIPortEventMap>()(
+    is,
+    port => ({
+      tag: 'MIDIPortStateChange',
+      eventListener: {
+        target: EMIDIPort.assumeImpl(port)._port,
+        type: 'statechange',
+      },
+      spanAttributes: {
+        spanTargetName: 'MIDI port',
+        port: Util.getStaticMIDIPortInfo(port),
+      },
+      nullableFieldName: 'port',
+    }),
+    rawPort =>
+      ({
+        newState: rawPort
+          ? ({
+              ofDevice: rawPort.state,
+              ofConnection: rawPort.connection,
+            } as const)
+          : null,
+      }) as const,
+    // TODO: check this type is actually needed
+  ) as DualMakeStateChangesStream<THighLevelPortType>
+
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export const makePortStateChangesStreamByPort =
+  makePortStateChangesStreamFactory(EMIDIPort.is)
+
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export const makeInputStateChangesStreamByPort =
+  makePortStateChangesStreamFactory(EMIDIInput.is)
+
+/**
+ * Function to create a stream of remapped {@linkcode MIDIConnectionEvent}s
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export const makeOutputStateChangesStreamByPort =
+  makePortStateChangesStreamFactory(EMIDIOutput.is)
+
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode createStreamMakerFrom}
+ */
+export interface DualMakeStateChangesStream<
+  THighLevelPortType extends MIDIPortType = MIDIPortType,
+> extends MakeStateChangesStreamPortFirst<THighLevelPortType>,
+    MakeStateChangesStreamPortLast<THighLevelPortType> {}
+
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode createStreamMakerFrom}
+ */
+export interface MakeStateChangesStreamPortFirst<
+  THighLevelPortType extends MIDIPortType = MIDIPortType,
+> {
+  /**
+   * @param options Passing a value of a `boolean` type is equivalent to setting `options.capture`
+   * property
+   */
+  <
+    TPortType extends THighLevelPortType,
+    const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined,
+    E = never,
+    R = never,
+  >(
+    polymorphicPort: EMIDIPort.PolymorphicPort<E, R, TPortType>,
+    options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+  ): StateChangesStream<TOnNullStrategy, TPortType, E, R>
+}
+
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode createStreamMakerFrom}
+ */
+export interface MakeStateChangesStreamPortLast<
+  THighLevelPortType extends MIDIPortType = MIDIPortType,
+> {
+  /**
+   * @param options Passing a value of a `boolean` type is equivalent to setting `options.capture`
+   * property
+   */
+  <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(
+    options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+  ): {
+    /**
+     *
+     *
+     */
+    <TPortType extends THighLevelPortType, E = never, R = never>(
+      polymorphicPort: EMIDIPort.PolymorphicPort<E, R, TPortType>,
+    ): StateChangesStream<TOnNullStrategy, TPortType, E, R>
+  }
+}
+
+/**
+ * A custom type is needed because the port type will be generic, but this is
+ * not possible if using just {@linkcode createStreamMakerFrom}
+ */
+export interface StateChangesStream<
+  TOnNullStrategy extends StreamMaker.OnNullStrategy,
+  TPortType extends MIDIPortType,
+  E = never,
+  R = never,
+> extends StreamMaker.BuiltStream<
+    'MIDIPortStateChange',
+    EMIDIPort.EMIDIPort<TPortType>,
+    {
+      readonly newState: {
+        readonly ofDevice: MIDIPortDeviceState
+        readonly ofConnection: MIDIPortConnectionState
+      } | null
+    },
+    TOnNullStrategy,
+    E,
+    R
+  > {}

package/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.ts

@@ -0,0 +1,14 @@
+// TODO: makeInputStateChangesStreamByPortIdAndAccess
+export const makeInputStateChangesStreamByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: makeOutputStateChangesStreamByPortIdAndAccess
+export const makeOutputStateChangesStreamByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: makePortStateChangesStreamByPortIdAndAccess
+export const makePortStateChangesStreamByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}

package/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.ts

@@ -0,0 +1,51 @@
+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 '../getPortByPortId/getPortByPortIdInContext.ts'
+import type * as StreamMaker from '../StreamMaker.ts'
+import * as Make from './makePortStateChangesStreamByPort.ts'
+
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export const makePortStateChangesStreamByPortIdInContext = <
+  const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined,
+>(
+  id: EMIDIPort.BothId,
+  options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+) =>
+  Make.makePortStateChangesStreamByPort(
+    Get.getPortByPortIdInContext(id),
+    options,
+  )
+
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export const makeInputStateChangesStreamByPortIdInContext = <
+  const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined,
+>(
+  id: EMIDIInput.Id,
+  options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+) =>
+  Make.makeInputStateChangesStreamByPort(
+    Get.getInputByPortIdInContext(id),
+    options,
+  )
+
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export const makeOutputStateChangesStreamByPortIdInContext = <
+  const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined,
+>(
+  id: EMIDIOutput.Id,
+  options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+) =>
+  Make.makeOutputStateChangesStreamByPort(
+    Get.getOutputByPortIdInContext(id),
+    options,
+  )

package/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPort.ts

@@ -0,0 +1,127 @@
+import * as EFunction from 'effect/Function'
+import * as Util from '../../util.ts'
+import * as Get from '../getMutablePortProperty/getMutablePortPropertyByPort.ts'
+
+/**
+ *
+ */
+export const isPortDeviceConnectedByPort = EFunction.flow(
+  Get.getPortDeviceStateByPort,
+  Util.isDeviceConnected,
+)
+
+/**
+ *
+ */
+export const isPortDeviceDisconnectedByPort = EFunction.flow(
+  Get.getPortDeviceStateByPort,
+  Util.isDeviceDisconnected,
+)
+
+/**
+ *
+ */
+export const isPortConnectionOpenByPort = EFunction.flow(
+  Get.getPortConnectionStateByPort,
+  Util.isConnectionOpen,
+)
+
+/**
+ *
+ */
+export const isPortConnectionPendingByPort = EFunction.flow(
+  Get.getPortConnectionStateByPort,
+  Util.isConnectionPending,
+)
+
+/**
+ *
+ */
+export const isPortConnectionClosedByPort = EFunction.flow(
+  Get.getPortConnectionStateByPort,
+  Util.isConnectionClosed,
+)
+
+//////////////////////////////
+
+/**
+ *
+ */
+export const isInputDeviceConnectedByPort = EFunction.flow(
+  Get.getInputDeviceStateByPort,
+  Util.isDeviceConnected,
+)
+
+/**
+ *
+ */
+export const isInputDeviceDisconnectedByPort = EFunction.flow(
+  Get.getInputDeviceStateByPort,
+  Util.isDeviceDisconnected,
+)
+
+/**
+ *
+ */
+export const isInputConnectionOpenByPort = EFunction.flow(
+  Get.getInputConnectionStateByPort,
+  Util.isConnectionOpen,
+)
+
+/**
+ *
+ */
+export const isInputConnectionPendingByPort = EFunction.flow(
+  Get.getInputConnectionStateByPort,
+  Util.isConnectionPending,
+)
+
+/**
+ *
+ */
+export const isInputConnectionClosedByPort = EFunction.flow(
+  Get.getInputConnectionStateByPort,
+  Util.isConnectionClosed,
+)
+
+//////////////////////////////
+
+/**
+ *
+ */
+export const isOutputDeviceConnectedByPort = EFunction.flow(
+  Get.getOutputDeviceStateByPort,
+  Util.isDeviceConnected,
+)
+
+/**
+ *
+ */
+export const isOutputDeviceDisconnectedByPort = EFunction.flow(
+  Get.getOutputDeviceStateByPort,
+  Util.isDeviceDisconnected,
+)
+
+/**
+ *
+ */
+export const isOutputConnectionOpenByPort = EFunction.flow(
+  Get.getOutputConnectionStateByPort,
+  Util.isConnectionOpen,
+)
+
+/**
+ *
+ */
+export const isOutputConnectionPendingByPort = EFunction.flow(
+  Get.getOutputConnectionStateByPort,
+  Util.isConnectionPending,
+)
+
+/**
+ *
+ */
+export const isOutputConnectionClosedByPort = EFunction.flow(
+  Get.getOutputConnectionStateByPort,
+  Util.isConnectionClosed,
+)

package/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.ts

@@ -0,0 +1,74 @@
+// TODO: isInputConnectionClosedByPortIdAndAccess
+export const isInputConnectionClosedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputConnectionOpenByPortIdAndAccess
+export const isInputConnectionOpenByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputConnectionPendingByPortIdAndAccess
+export const isInputConnectionPendingByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputDeviceConnectedByPortIdAndAccess
+export const isInputDeviceConnectedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputDeviceDisconnectedByPortIdAndAccess
+export const isInputDeviceDisconnectedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputConnectionClosedByPortIdAndAccess
+export const isOutputConnectionClosedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputConnectionOpenByPortIdAndAccess
+export const isOutputConnectionOpenByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputConnectionPendingByPortIdAndAccess
+export const isOutputConnectionPendingByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputDeviceConnectedByPortIdAndAccess
+export const isOutputDeviceConnectedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputDeviceDisconnectedByPortIdAndAccess
+export const isOutputDeviceDisconnectedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortConnectionClosedByPortIdAndAccess
+export const isPortConnectionClosedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortConnectionOpenByPortIdAndAccess
+export const isPortConnectionOpenByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortConnectionPendingByPortIdAndAccess
+export const isPortConnectionPendingByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortDeviceConnectedByPortIdAndAccess
+export const isPortDeviceConnectedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortDeviceDisconnectedByPortIdAndAccess
+export const isPortDeviceDisconnectedByPortIdAndAccess = () => {
+  throw new Error('not implemented')
+}

package/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.ts

@@ -0,0 +1,74 @@
+// TODO: isInputConnectionClosedByPortIdInContext
+export const isInputConnectionClosedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputConnectionOpenByPortIdInContext
+export const isInputConnectionOpenByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputConnectionPendingByPortIdInContext
+export const isInputConnectionPendingByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputDeviceConnectedByPortIdInContext
+export const isInputDeviceConnectedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isInputDeviceDisconnectedByPortIdInContext
+export const isInputDeviceDisconnectedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputConnectionClosedByPortIdInContext
+export const isOutputConnectionClosedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputConnectionOpenByPortIdInContext
+export const isOutputConnectionOpenByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputConnectionPendingByPortIdInContext
+export const isOutputConnectionPendingByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputDeviceConnectedByPortIdInContext
+export const isOutputDeviceConnectedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isOutputDeviceDisconnectedByPortIdInContext
+export const isOutputDeviceDisconnectedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortConnectionClosedByPortIdInContext
+export const isPortConnectionClosedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortConnectionOpenByPortIdInContext
+export const isPortConnectionOpenByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortConnectionPendingByPortIdInContext
+export const isPortConnectionPendingByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortDeviceConnectedByPortIdInContext
+export const isPortDeviceConnectedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}
+
+// TODO: isPortDeviceDisconnectedByPortIdInContext
+export const isPortDeviceDisconnectedByPortIdInContext = () => {
+  throw new Error('not implemented')
+}

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

@@ -0,0 +1,63 @@
+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')