effect-web-midi 0.1.0

package/src/internal/MIDIPortMethodCalls/actOnPort.ts

@@ -0,0 +1,66 @@
+/** 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 type * as EMIDIPort from '../EMIDIPort.ts'
+import type * as Get from '../getPortByPortId/getPortByPortIdAndAccess.ts'
+import type * as Make from './makeMIDIPortMethodCallerFactory.ts'
+
+/**
+ *
+ * @internal
+ */
+export const actOnPort = <
+  TTypeOfPortId extends MIDIPortType,
+  TPortTypeReturnedFromAccess extends TPortTypeSupportedInActing &
+    TTypeOfPortId,
+  TPortTypeSupportedInActing extends MIDIPortType,
+  TPortGettingError = never,
+  TPortGettingRequirement = never,
+  TPortActingError = never,
+  TPortActingRequirement = never,
+>(
+  portGetterFromAccessAndPortId: Get.GetPortById<
+    TPortTypeReturnedFromAccess,
+    TTypeOfPortId,
+    never,
+    never,
+    TPortGettingError,
+    TPortGettingRequirement
+  >,
+  act: Make.TouchPort<
+    TPortActingError,
+    TPortActingRequirement,
+    TPortTypeSupportedInActing
+  >,
+): EMIDIAccess.GetThingByPortId<
+  EMIDIAccess.EMIDIAccessInstance,
+  TPortTypeReturnedFromAccess,
+  never,
+  never,
+  TPortGettingError | TPortActingError,
+  TPortGettingRequirement | TPortActingRequirement
+> =>
+  EFunction.dual(
+    2,
+    (polymorphicAccess, portId) =>
+      Effect.gen(function* () {
+        const access = yield* EMIDIAccess.resolve(polymorphicAccess)
+
+        const port = yield* portGetterFromAccessAndPortId(
+          access,
+          portId as unknown as EMIDIPort.Id<TTypeOfPortId>,
+        )
+
+        const actEffect = act(
+          port as unknown as EMIDIPort.EMIDIPort<TPortTypeSupportedInActing>,
+        )
+
+        yield* actEffect
+
+        return access
+        // biome-ignore lint/suspicious/noExplicitAny: FallbackOnUnknownOrAny backfired a bit, but I don't care about it anymore
+      }) as any,
+  )

package/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPort.ts

@@ -0,0 +1,38 @@
+/** 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 F from '../makeMIDIPortMethodCallerFactory.ts'
+
+/**
+ * @internal
+ *
+ * exported for acquire-release
+ */
+export const makePortConnectionCloser = F.makeMIDIPortMethodCallerFactory(
+  'close',
+  () => err => {
+    throw err
+  },
+)
+
+/**
+ *
+ */
+export const closePortConnectionByPort = makePortConnectionCloser(EMIDIPort.is)
+
+/**
+ *
+ */
+export const closeInputConnectionByPort = makePortConnectionCloser(
+  EMIDIInput.is,
+)
+
+/**
+ *
+ */
+export const closeOutputConnectionByPort = makePortConnectionCloser(
+  EMIDIOutput.is,
+)

package/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdAndAccess.ts

@@ -0,0 +1,38 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import {
+  getInputByPortIdAndAccess,
+  getOutputByPortIdAndAccess,
+  getPortByPortIdAndAccess,
+} from '../../getPortByPortId/getPortByPortIdAndAccess.ts'
+import { actOnPort } from '../actOnPort.ts'
+import {
+  closeInputConnectionByPort,
+  closeOutputConnectionByPort,
+  closePortConnectionByPort,
+} from './closePortConnectionByPort.ts'
+
+/**
+ *
+ */
+export const closePortConnectionByPortIdAndAccess = actOnPort(
+  getPortByPortIdAndAccess,
+  closePortConnectionByPort,
+)
+
+/**
+ *
+ */
+export const closeInputConnectionByPortIdAndAccess = actOnPort(
+  getInputByPortIdAndAccess,
+  closeInputConnectionByPort,
+)
+
+/**
+ *
+ */
+export const closeOutputConnectionByPortIdAndAccess = actOnPort(
+  getOutputByPortIdAndAccess,
+  closeOutputConnectionByPort,
+)

package/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.ts

@@ -0,0 +1,27 @@
+import { flow } from 'effect/Function'
+import * as Get from '../../getPortByPortId/getPortByPortIdInContext.ts'
+import * as Close from './closePortConnectionByPort.ts'
+
+/**
+ *
+ */
+export const closePortConnectionByPortIdInContext = flow(
+  Get.getPortByPortIdInContext,
+  Close.closePortConnectionByPort,
+)
+
+/**
+ *
+ */
+export const closeInputConnectionByPortIdInContext = flow(
+  Get.getInputByPortIdInContext,
+  Close.closeInputConnectionByPort,
+)
+
+/**
+ *
+ */
+export const closeOutputConnectionByPortIdInContext = flow(
+  Get.getOutputByPortIdInContext,
+  Close.closeOutputConnectionByPort,
+)

package/src/internal/MIDIPortMethodCalls/makeMIDIPortMethodCallerFactory.ts

@@ -0,0 +1,73 @@
+/** 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 EMIDIPort from '../EMIDIPort.ts'
+import * as Util from '../util.ts'
+
+/**
+ * @internal
+ */
+export const makeMIDIPortMethodCallerFactory =
+  <TError = never>(
+    method: 'close' | 'open',
+    mapError: (id: EMIDIPort.BothId) => (err: unknown) => TError,
+  ) =>
+  <THighLevelPortType extends MIDIPortType>(
+    is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>,
+  ): TouchPort<TError, never, THighLevelPortType> =>
+    Effect.fn(`EMIDIPort.${method}`)(function* <
+      TPortType extends THighLevelPortType,
+      TPortGettingError = never,
+      TPortGettingRequirement = never,
+    >(
+      polymorphicPort: EMIDIPort.PolymorphicPort<
+        TPortGettingError,
+        TPortGettingRequirement,
+        TPortType
+      >,
+    ) {
+      const port = yield* Util.fromPolymorphic(
+        polymorphicPort,
+        is as unknown as (
+          port: unknown,
+        ) => port is EMIDIPort.EMIDIPort<TPortType>,
+      )
+
+      yield* Effect.annotateCurrentSpan({
+        method,
+        port: Util.getStaticMIDIPortInfo(port),
+      })
+
+      yield* Effect.tryPromise({
+        try: () => EMIDIPort.assumeImpl(port)._port[method](),
+        catch: mapError(port.id),
+      })
+
+      return port
+    })
+
+export interface TouchPort<
+  TAdditionalError,
+  TAdditionalRequirement,
+  THighLevelPortType extends MIDIPortType,
+> {
+  /**
+   * @returns An effect with the same port for easier chaining of operations
+   */
+  <
+    TPortType extends THighLevelPortType,
+    TPortGettingError = never,
+    TPortGettingRequirement = never,
+  >(
+    polymorphicPort: EMIDIPort.PolymorphicPort<
+      TPortGettingError,
+      TPortGettingRequirement,
+      TPortType
+    >,
+  ): Effect.Effect<
+    EMIDIPort.EMIDIPort<TPortType>,
+    TPortGettingError | TAdditionalError,
+    TPortGettingRequirement | TAdditionalRequirement
+  >
+}

package/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.ts

@@ -0,0 +1,44 @@
+import * as EMIDIInput from '../../EMIDIInput.ts'
+import * as EMIDIOutput from '../../EMIDIOutput.ts'
+import * as EMIDIPort from '../../EMIDIPort.ts'
+import { remapErrorByName, UnavailablePortError } from '../../errors.ts'
+import { makeMIDIPortMethodCallerFactory } from '../makeMIDIPortMethodCallerFactory.ts'
+
+/**
+ * @internal
+ *
+ * exported for acquire-release
+ */
+export const makePortConnectionOpener = makeMIDIPortMethodCallerFactory(
+  'open',
+  portId =>
+    remapErrorByName(
+      {
+        NotAllowedError: UnavailablePortError,
+        // InvalidAccessError is kept for compatibility reason
+        // (https://github.com/WebAudio/web-midi-api/pull/278):
+        InvalidAccessError: UnavailablePortError,
+
+        InvalidStateError: UnavailablePortError,
+      },
+      'MIDI port open error handling absurd',
+      { portId },
+    ),
+)
+
+/**
+ *
+ */
+export const openPortConnectionByPort = makePortConnectionOpener(EMIDIPort.is)
+
+/**
+ *
+ */
+export const openInputConnectionByPort = makePortConnectionOpener(EMIDIInput.is)
+
+/**
+ *
+ */
+export const openOutputConnectionByPort = makePortConnectionOpener(
+  EMIDIOutput.is,
+)

package/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.ts

@@ -0,0 +1,38 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import {
+  getInputByPortIdAndAccess,
+  getOutputByPortIdAndAccess,
+  getPortByPortIdAndAccess,
+} from '../../getPortByPortId/getPortByPortIdAndAccess.ts'
+import { actOnPort } from '../actOnPort.ts'
+import {
+  openInputConnectionByPort,
+  openOutputConnectionByPort,
+  openPortConnectionByPort,
+} from './openPortConnectionByPort.ts'
+
+/**
+ *
+ */
+export const openPortConnectionByPortIdAndAccess = actOnPort(
+  getPortByPortIdAndAccess,
+  openPortConnectionByPort,
+)
+
+/**
+ *
+ */
+export const openInputConnectionByPortIdAndAccess = actOnPort(
+  getInputByPortIdAndAccess,
+  openInputConnectionByPort,
+)
+
+/**
+ *
+ */
+export const openOutputConnectionByPortIdAndAccess = actOnPort(
+  getOutputByPortIdAndAccess,
+  openOutputConnectionByPort,
+)

package/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.ts

@@ -0,0 +1,27 @@
+import { flow } from 'effect/Function'
+import * as Get from '../../getPortByPortId/getPortByPortIdInContext.ts'
+import * as Open from './openPortConnectionByPort.ts'
+
+/**
+ *
+ */
+export const openPortConnectionByPortIdInContext = flow(
+  Get.getPortByPortIdInContext,
+  Open.openPortConnectionByPort,
+)
+
+/**
+ *
+ */
+export const openInputConnectionByPortIdInContext = flow(
+  Get.getInputByPortIdInContext,
+  Open.openInputConnectionByPort,
+)
+
+/**
+ *
+ */
+export const openOutputConnectionByPortIdInContext = flow(
+  Get.getOutputByPortIdInContext,
+  Open.openOutputConnectionByPort,
+)