effect-web-midi 0.2.3

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
+ */
+export 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 DualMakeStateChangesStreamByPort<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 StreamMaker.createStreamMakerFrom}
+ */
+export interface DualMakeStateChangesStreamByPort<
+  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 StreamMaker.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 StreamMaker.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 StreamMaker.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,135 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import * as EFunction from 'effect/Function'
+
+import * as EMIDIAccess from '../EMIDIAccess.ts'
+import type * as EMIDIPort from '../EMIDIPort.ts'
+import * as Get from '../getPortByPortId/getPortByPortIdAndAccess.ts'
+import type * as MIDIErrors from '../MIDIErrors.ts'
+import type * as StreamMaker from '../StreamMaker.ts'
+import * as Util from '../Util.ts'
+import * as Make from './makePortStateChangesStreamByPort.ts'
+
+const wrap = <
+  TTypeOfPortId extends MIDIPortType,
+  TPortGettingError = never,
+  TPortGettingRequirement = never,
+>(
+  makePortStateChangesStream: Make.DualMakeStateChangesStreamByPort<TTypeOfPortId>,
+  getPortFromAccessAndPortId: Get.GetPortById<
+    TTypeOfPortId,
+    TTypeOfPortId,
+    never,
+    never,
+    TPortGettingError,
+    TPortGettingRequirement
+  >,
+): MakePortStateChangesStreamByIdAndAccess<
+  TTypeOfPortId,
+  TPortGettingError,
+  TPortGettingRequirement
+> =>
+  EFunction.dual(
+    Util.polymorphicCheckInDual(EMIDIAccess.is),
+    (polymorphicAccess, id, options) =>
+      makePortStateChangesStream(
+        getPortFromAccessAndPortId(polymorphicAccess, id),
+        options,
+      ),
+  )
+
+/**
+ *
+ */
+export const makePortStateChangesStreamByPortIdAndAccess = wrap(
+  Make.makePortStateChangesStreamByPort,
+  Get.getPortByPortIdAndAccess,
+)
+
+/**
+ *
+ */
+export const makeInputStateChangesStreamByPortIdAndAccess = wrap(
+  Make.makeInputStateChangesStreamByPort,
+  Get.getInputByPortIdAndAccess,
+)
+
+/**
+ *
+ */
+export const makeOutputStateChangesStreamByPortIdAndAccess = wrap(
+  Make.makeOutputStateChangesStreamByPort,
+  Get.getOutputByPortIdAndAccess,
+)
+
+export interface MakePortStateChangesStreamByIdAndAccess<
+  TTypeOfPortId extends MIDIPortType,
+  TPortGettingError,
+  TPortGettingRequirement,
+> extends MakePortStateChangesStreamByIdAccessLast<
+      TTypeOfPortId,
+      TPortGettingError,
+      TPortGettingRequirement
+    >,
+    MakePortStateChangesStreamByIdAccessFirst<
+      TTypeOfPortId,
+      TPortGettingError,
+      TPortGettingRequirement
+    > {}
+
+export interface MakePortStateChangesStreamByIdAccessFirst<
+  TTypeOfPortId extends MIDIPortType,
+  TPortGettingError,
+  TPortGettingRequirement,
+> {
+  /**
+   *
+   */
+  <
+    TAccessError = never,
+    TAccessRequirement = never,
+    const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined,
+  >(
+    polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<
+      TAccessError,
+      TAccessRequirement
+    >,
+    id: EMIDIPort.Id<TTypeOfPortId>,
+    options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+  ): Make.StateChangesStream<
+    TOnNullStrategy,
+    TTypeOfPortId,
+    MIDIErrors.PortNotFoundError | TAccessError | TPortGettingError,
+    TAccessRequirement | TPortGettingRequirement
+  >
+}
+
+export interface MakePortStateChangesStreamByIdAccessLast<
+  TTypeOfPortId extends MIDIPortType,
+  TPortGettingError,
+  TPortGettingRequirement,
+> {
+  /**
+   *
+   */
+  <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(
+    id: EMIDIPort.Id<TTypeOfPortId>,
+    options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+  ): {
+    /**
+     *
+     */
+    <TAccessError = never, TAccessRequirement = never>(
+      polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<
+        TAccessError,
+        TAccessRequirement
+      >,
+    ): Make.StateChangesStream<
+      TOnNullStrategy,
+      TTypeOfPortId,
+      MIDIErrors.PortNotFoundError | TAccessError | TPortGettingError,
+      TAccessRequirement | TPortGettingRequirement
+    >
+  }
+}

package/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.ts

@@ -0,0 +1,70 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import type * as EMIDIPort from '../../EMIDIPort.ts'
+import * as EMIDIAccess from '../EMIDIAccess.ts'
+import type * as MIDIErrors from '../MIDIErrors.ts'
+import type * as StreamMaker from '../StreamMaker.ts'
+import * as Make from './makePortStateChangesStreamByPortIdAndAccess.ts'
+
+const wrap =
+  <
+    TTypeOfPortId extends MIDIPortType,
+    TPortGettingError,
+    TPortGettingRequirement,
+  >(
+    makeStream: Make.MakePortStateChangesStreamByIdAndAccess<
+      TTypeOfPortId,
+      TPortGettingError,
+      TPortGettingRequirement
+    >,
+  ): MakePortStateChangesStreamByPortIdInContext<
+    TTypeOfPortId,
+    TPortGettingError,
+    TPortGettingRequirement
+  > =>
+  (id, options) =>
+    makeStream(EMIDIAccess.EMIDIAccess, id, options)
+
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export const makePortStateChangesStreamByPortIdInContext = wrap(
+  Make.makePortStateChangesStreamByPortIdAndAccess,
+)
+
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export const makeInputStateChangesStreamByPortIdInContext = wrap(
+  Make.makeInputStateChangesStreamByPortIdAndAccess,
+)
+
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export const makeOutputStateChangesStreamByPortIdInContext = wrap(
+  Make.makeOutputStateChangesStreamByPortIdAndAccess,
+)
+
+interface MakePortStateChangesStreamByPortIdInContext<
+  TTypeOfPortId extends MIDIPortType,
+  TPortGettingError,
+  TPortGettingRequirement,
+> {
+  /**
+   *
+   */
+  <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(
+    id: EMIDIPort.Id<TTypeOfPortId>,
+    options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>,
+  ): EMIDIPort.StateChangesStream<
+    TOnNullStrategy,
+    TTypeOfPortId,
+    TPortGettingError | MIDIErrors.PortNotFoundError,
+    TPortGettingRequirement | EMIDIAccess.EMIDIAccess
+  >
+}

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

@@ -0,0 +1,128 @@
+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 😿  YET!! 🤩')
+}
+
+// TODO: isInputConnectionOpenByPortIdAndAccess
+export const isInputConnectionOpenByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isInputConnectionPendingByPortIdAndAccess
+export const isInputConnectionPendingByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isInputDeviceConnectedByPortIdAndAccess
+export const isInputDeviceConnectedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isInputDeviceDisconnectedByPortIdAndAccess
+export const isInputDeviceDisconnectedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isOutputConnectionClosedByPortIdAndAccess
+export const isOutputConnectionClosedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isOutputConnectionOpenByPortIdAndAccess
+export const isOutputConnectionOpenByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isOutputConnectionPendingByPortIdAndAccess
+export const isOutputConnectionPendingByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isOutputDeviceConnectedByPortIdAndAccess
+export const isOutputDeviceConnectedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isOutputDeviceDisconnectedByPortIdAndAccess
+export const isOutputDeviceDisconnectedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isPortConnectionClosedByPortIdAndAccess
+export const isPortConnectionClosedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isPortConnectionOpenByPortIdAndAccess
+export const isPortConnectionOpenByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isPortConnectionPendingByPortIdAndAccess
+export const isPortConnectionPendingByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isPortDeviceConnectedByPortIdAndAccess
+export const isPortDeviceConnectedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}
+
+// TODO: isPortDeviceDisconnectedByPortIdAndAccess
+export const isPortDeviceDisconnectedByPortIdAndAccess = () => {
+  throw new Error('Not implemented 😿  YET!! 🤩')
+}

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

@@ -0,0 +1,132 @@
+import * as EFunction from 'effect/Function'
+
+import * as Get from '../../getPortByPortId/getPortByPortIdInContext.ts'
+import * as Check from './doesMutablePortPropertyHaveSpecificValueByPort.ts'
+
+/**
+ *
+ */
+export const closePortConnectionByPortIdInContext = EFunction.flow(
+  Get.getInputByPortIdInContext,
+  Check.isInputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isInputConnectionClosedByPortIdInContext = EFunction.flow(
+  Get.getInputByPortIdInContext,
+  Check.isInputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isInputConnectionOpenByPortIdInContext = EFunction.flow(
+  Get.getInputByPortIdInContext,
+  Check.isInputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isInputConnectionPendingByPortIdInContext = EFunction.flow(
+  Get.getInputByPortIdInContext,
+  Check.isInputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isInputDeviceConnectedByPortIdInContext = EFunction.flow(
+  Get.getInputByPortIdInContext,
+  Check.isInputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isInputDeviceDisconnectedByPortIdInContext = EFunction.flow(
+  Get.getInputByPortIdInContext,
+  Check.isInputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isOutputConnectionClosedByPortIdInContext = EFunction.flow(
+  Get.getOutputByPortIdInContext,
+  Check.isOutputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isOutputConnectionOpenByPortIdInContext = EFunction.flow(
+  Get.getOutputByPortIdInContext,
+  Check.isOutputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isOutputConnectionPendingByPortIdInContext = EFunction.flow(
+  Get.getOutputByPortIdInContext,
+  Check.isOutputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isOutputDeviceConnectedByPortIdInContext = EFunction.flow(
+  Get.getOutputByPortIdInContext,
+  Check.isOutputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isOutputDeviceDisconnectedByPortIdInContext = EFunction.flow(
+  Get.getOutputByPortIdInContext,
+  Check.isOutputConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isPortConnectionClosedByPortIdInContext = EFunction.flow(
+  Get.getPortByPortIdInContext,
+  Check.isPortConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isPortConnectionOpenByPortIdInContext = EFunction.flow(
+  Get.getPortByPortIdInContext,
+  Check.isPortConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isPortConnectionPendingByPortIdInContext = EFunction.flow(
+  Get.getPortByPortIdInContext,
+  Check.isPortConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isPortDeviceConnectedByPortIdInContext = EFunction.flow(
+  Get.getPortByPortIdInContext,
+  Check.isPortConnectionClosedByPort,
+)
+
+/**
+ *
+ */
+export const isPortDeviceDisconnectedByPortIdInContext = EFunction.flow(
+  Get.getPortByPortIdInContext,
+  Check.isPortConnectionClosedByPort,
+)