effect-web-midi 0.1.0

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.d.ts

@@ -0,0 +1,16 @@
+import type * as Scope from 'effect/Scope';
+import type { UnavailablePortError } from '../../errors.ts';
+import type { TouchPort } from '../makeMIDIPortMethodCallerFactory.ts';
+/**
+ *
+ */
+export declare const acquireReleasePortConnectionByPort: TouchPort<UnavailablePortError, Scope.Scope, MIDIPortType>;
+/**
+ *
+ */
+export declare const acquireReleaseInputConnectionByPort: TouchPort<UnavailablePortError, Scope.Scope, "input">;
+/**
+ *
+ */
+export declare const acquireReleaseOutputConnectionByPort: TouchPort<UnavailablePortError, Scope.Scope, "output">;
+//# sourceMappingURL=acquireReleasePortConnectionByPort.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquireReleasePortConnectionByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAI1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAA;AAmBtE;;GAEG;AACH,eAAO,MAAM,kCAAkC,4DACD,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,mCAAmC,uDACD,CAAA;AAE/C;;GAEG;AACH,eAAO,MAAM,oCAAoC,wDACD,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.d.ts

@@ -0,0 +1,15 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+/**
+ *
+ */
+export declare const acquireReleasePortConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input" | "output", never, never, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseInputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input", never, never, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseOutputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "output", never, never, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("effect/Scope").Scope>;
+//# sourceMappingURL=acquireReleasePortConnectionByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquireReleasePortConnectionByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.ts"],"names":[],"mappings":"AACA;gEACgE;AAchE;;GAEG;AACH,eAAO,MAAM,6CAA6C,mQAGzD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8CAA8C,wPAG1D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+CAA+C,yPAG3D,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare const acquireReleasePortConnectionByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input" | "output">, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess | import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseInputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input">, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess | import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseOutputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"output">, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess | import("effect/Scope").Scope>;
+//# sourceMappingURL=acquireReleasePortConnectionByPortIdInContext.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquireReleasePortConnectionByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,6CAA6C,kTAGzD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8CAA8C,+VAG1D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+CAA+C,iWAG3D,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/actOnPort.d.ts

@@ -0,0 +1,11 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as EMIDIAccess from '../EMIDIAccess.ts';
+import type * as Get from '../getPortByPortId/getPortByPortIdAndAccess.ts';
+import type * as Make from './makeMIDIPortMethodCallerFactory.ts';
+/**
+ *
+ * @internal
+ */
+export declare 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>;
+//# sourceMappingURL=actOnPort.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/actOnPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actOnPort.d.ts","sourceRoot":"","sources":["../../../../src/internal/MIDIPortMethodCalls/actOnPort.ts"],"names":[],"mappings":"AAAA;gEACgE;AAIhE,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,KAAK,GAAG,MAAM,gDAAgD,CAAA;AAC1E,OAAO,KAAK,KAAK,IAAI,MAAM,sCAAsC,CAAA;AAEjE;;;GAGG;AACH,eAAO,MAAM,SAAS,GACpB,aAAa,SAAS,YAAY,EAClC,2BAA2B,SAAS,0BAA0B,GAC5D,aAAa,EACf,0BAA0B,SAAS,YAAY,EAC/C,iBAAiB,GAAG,KAAK,EACzB,uBAAuB,GAAG,KAAK,EAC/B,gBAAgB,GAAG,KAAK,EACxB,sBAAsB,GAAG,KAAK,EAE9B,+BAA+B,GAAG,CAAC,WAAW,CAC5C,2BAA2B,EAC3B,aAAa,EACb,KAAK,EACL,KAAK,EACL,iBAAiB,EACjB,uBAAuB,CACxB,EACD,KAAK,IAAI,CAAC,SAAS,CACjB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,CAC3B,KACA,WAAW,CAAC,gBAAgB,CAC7B,WAAW,CAAC,mBAAmB,EAC/B,2BAA2B,EAC3B,KAAK,EACL,KAAK,EACL,iBAAiB,GAAG,gBAAgB,EACpC,uBAAuB,GAAG,sBAAsB,CAsB/C,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPort.d.ts

@@ -0,0 +1,23 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as EMIDIPort from '../../EMIDIPort.ts';
+import * as F from '../makeMIDIPortMethodCallerFactory.ts';
+/**
+ * @internal
+ *
+ * exported for acquire-release
+ */
+export declare const makePortConnectionCloser: <THighLevelPortType extends MIDIPortType>(is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>) => F.TouchPort<never, never, THighLevelPortType>;
+/**
+ *
+ */
+export declare const closePortConnectionByPort: F.TouchPort<never, never, MIDIPortType>;
+/**
+ *
+ */
+export declare const closeInputConnectionByPort: F.TouchPort<never, never, "input">;
+/**
+ *
+ */
+export declare const closeOutputConnectionByPort: F.TouchPort<never, never, "output">;
+//# sourceMappingURL=closePortConnectionByPort.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closePortConnectionByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPort.ts"],"names":[],"mappings":"AAAA;gEACgE;AAIhE,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,CAAC,MAAM,uCAAuC,CAAA;AAE1D;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,oKAKpC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,yBAAyB,yCAAyC,CAAA;AAE/E;;GAEG;AACH,eAAO,MAAM,0BAA0B,oCAEtC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,qCAEvC,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdAndAccess.d.ts

@@ -0,0 +1,15 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+/**
+ *
+ */
+export declare const closePortConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input" | "output", never, never, import("../../errors.ts").PortNotFoundError, never>;
+/**
+ *
+ */
+export declare const closeInputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input", never, never, import("../../errors.ts").PortNotFoundError, never>;
+/**
+ *
+ */
+export declare const closeOutputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "output", never, never, import("../../errors.ts").PortNotFoundError, never>;
+//# sourceMappingURL=closePortConnectionByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closePortConnectionByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdAndAccess.ts"],"names":[],"mappings":"AAAA;gEACgE;AAchE;;GAEG;AACH,eAAO,MAAM,oCAAoC,2LAGhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qCAAqC,gLAGjD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,sCAAsC,iLAGlD,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare const closePortConnectionByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input" | "output">, import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const closeInputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input">, import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const closeOutputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"output">, import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+//# sourceMappingURL=closePortConnectionByPortIdInContext.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closePortConnectionByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,oCAAoC,kOAGhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qCAAqC,+QAGjD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,sCAAsC,iRAGlD,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/makeMIDIPortMethodCallerFactory.d.ts

@@ -0,0 +1,15 @@
+/** 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';
+/**
+ * @internal
+ */
+export declare 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>;
+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>;
+}
+//# sourceMappingURL=makeMIDIPortMethodCallerFactory.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/makeMIDIPortMethodCallerFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeMIDIPortMethodCallerFactory.d.ts","sourceRoot":"","sources":["../../../../src/internal/MIDIPortMethodCalls/makeMIDIPortMethodCallerFactory.ts"],"names":[],"mappings":"AAAA;gEACgE;AAEhE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAG5C;;GAEG;AACH,eAAO,MAAM,+BAA+B,GACzC,MAAM,GAAG,KAAK,EACb,QAAQ,OAAO,GAAG,MAAM,EACxB,UAAU,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,KAAK,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,MAE7D,kBAAkB,SAAS,YAAY,EACtC,IAAI,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,SAAS,CAAC,SAAS,CAAC,kBAAkB,CAAC,KACrE,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,kBAAkB,CA8B1C,CAAA;AAEN,MAAM,WAAW,SAAS,CACxB,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,SAAS,YAAY;IAEvC;;OAEG;IACH,CACE,SAAS,SAAS,kBAAkB,EACpC,iBAAiB,GAAG,KAAK,EACzB,uBAAuB,GAAG,KAAK,EAE/B,eAAe,EAAE,SAAS,CAAC,eAAe,CACxC,iBAAiB,EACjB,uBAAuB,EACvB,SAAS,CACV,GACA,MAAM,CAAC,MAAM,CACd,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,EAC9B,iBAAiB,GAAG,gBAAgB,EACpC,uBAAuB,GAAG,sBAAsB,CACjD,CAAA;CACF"}

package/dist-types/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.d.ts

@@ -0,0 +1,21 @@
+import * as EMIDIPort from '../../EMIDIPort.ts';
+import { UnavailablePortError } from '../../errors.ts';
+/**
+ * @internal
+ *
+ * exported for acquire-release
+ */
+export declare const makePortConnectionOpener: <THighLevelPortType extends MIDIPortType>(is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>) => import("../makeMIDIPortMethodCallerFactory.ts").TouchPort<UnavailablePortError, never, THighLevelPortType>;
+/**
+ *
+ */
+export declare const openPortConnectionByPort: import("../makeMIDIPortMethodCallerFactory.ts").TouchPort<UnavailablePortError, never, MIDIPortType>;
+/**
+ *
+ */
+export declare const openInputConnectionByPort: import("../makeMIDIPortMethodCallerFactory.ts").TouchPort<UnavailablePortError, never, "input">;
+/**
+ *
+ */
+export declare const openOutputConnectionByPort: import("../makeMIDIPortMethodCallerFactory.ts").TouchPort<UnavailablePortError, never, "output">;
+//# sourceMappingURL=openPortConnectionByPort.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openPortConnectionByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAoB,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAGxE;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,iOAepC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,sGAAyC,CAAA;AAE9E;;GAEG;AACH,eAAO,MAAM,yBAAyB,iGAA0C,CAAA;AAEhF;;GAEG;AACH,eAAO,MAAM,0BAA0B,kGAEtC,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.d.ts

@@ -0,0 +1,15 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+/**
+ *
+ */
+export declare const openPortConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input" | "output", never, never, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, never>;
+/**
+ *
+ */
+export declare const openInputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input", never, never, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, never>;
+/**
+ *
+ */
+export declare const openOutputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "output", never, never, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, never>;
+//# sourceMappingURL=openPortConnectionByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openPortConnectionByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.ts"],"names":[],"mappings":"AAAA;gEACgE;AAchE;;GAEG;AACH,eAAO,MAAM,mCAAmC,4OAG/C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oCAAoC,iOAGhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qCAAqC,kOAGjD,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare const openPortConnectionByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input" | "output">, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const openInputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input">, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+/**
+ *
+ */
+export declare const openOutputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"output">, import("../../errors.ts").UnavailablePortError | import("../../errors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess>;
+//# sourceMappingURL=openPortConnectionByPortIdInContext.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openPortConnectionByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,mCAAmC,mRAG/C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oCAAoC,gUAGhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qCAAqC,kUAGjD,CAAA"}

package/dist-types/src/internal/StreamMaker.d.ts

@@ -0,0 +1,202 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as Cause from 'effect/Cause';
+import * as Stream from 'effect/Stream';
+import * as Util from './util.ts';
+/**
+ * Set of possible ways to react when the MIDI-related event will have relevant
+ * field be null. Although there should be no sane scenario where it would be
+ * the case, it's still allowed by the spec, and for a better UX this lib lets
+ * the developer make a decision on how to handle such cases.
+ *
+ * - `fail` will add an error into a signature of a stream, allowing the user to
+ *   handle it
+ * - `die` will throw a defect, which won't be reflected as a possible failure
+ *   in types
+ * - `ignore` will just silently remove such events from the stream
+ * - `passthrough` - will pass such events with an unmodified content of the
+ *   relevant field
+ *
+ * @internal
+ */
+declare const validOnNullStrategies: Set<"fail" | "die" | "ignore" | "passthrough">;
+/**
+ * Helper utility to turn MIDI event listeners into effect's Streams.
+ *
+ * The signature is split into 2 calls, so that you are able at first call pass
+ * into generic an interface with `addEventListener` types of the raw web MIDI
+ * objects as keys and according event structures as values.
+ *
+ * **Second call arguments**
+ *
+ * - `isSelf` - Function determining if the maker was called as an overload with
+ *   all parameters passed all at once, or with them spread by 2 calls. `self`
+ *   will be later assigned to a `cameFrom` property of the object in the
+ *   success channel of the stream
+ *
+ * - `buildConfig` - Function that makes config out of an effectful version
+ *   (e.g. {@linkcode EMIDIAccess.EMIDIAccessInstance}, {@linkcode EMIDIInput.EMIDIInput},
+ *   {@linkcode EMIDIOutput.EMIDIOutput}) of a MIDI object.
+ *
+ * - `remapValueToContainer` - Callback that maps the value of the event's
+ *   selected field to an extension of the object inside stream's success
+ *   channel. All fields of the returned object must always be present and
+ *   should be consistently nullable, when the incoming event's field is null.
+ *
+ * @template TEventTypeToEventValueMap An interface with event types of raw
+ * Web MIDI objects as keys and according event structures as values. e.g.
+ * `MIDIAccessEventMap`, `MIDIPortEventMap`, `MIDIInputEventMap`
+ *
+ * @internal
+ */
+export declare const createStreamMakerFrom: <TEventTypeToEventValueMap extends object>() => <TEventTarget extends Stream.EventListener<TEventTypeToEventValueMap[TSelectedEventType]>, const TSelectedEventType extends Extract<keyof TEventTypeToEventValueMap, string>, const TNullableFieldName extends Extract<keyof TEventTypeToEventValueMap[TSelectedEventType], string>, TCameFrom, const TTag extends string, TContainerWithNullableFields extends object>(isSelf: (self: unknown) => self is TCameFrom, buildConfig: (self: TCameFrom) => StreamConfig<TTag, TEventTarget, TSelectedEventType, TNullableFieldName>, remapValueToContainer: (fieldValue: TEventTypeToEventValueMap[TSelectedEventType][TNullableFieldName]) => TContainerWithNullableFields) => DualStreamMaker<TCameFrom, TTag, TContainerWithNullableFields>;
+interface StreamConfig<TTag, TEventTarget, TSelectedEventType, TNullableFieldName> {
+    /**
+     * Tag that will be assigned to the object inside stream's success channel
+     */
+    readonly tag: TTag;
+    /**
+     * Config specifying where to attach the event listener
+     */
+    readonly eventListener: {
+        /**
+         * Native MIDI object (e.g. {@linkcode MIDIAccess},
+         * {@linkcode MIDIInput}, {@linkcode MIDIOutput}) that can have new
+         * listeners attached
+         */
+        readonly target: TEventTarget;
+        /**
+         * The type of event supported by the native MIDI object,
+         * `addEventListener`'s first argument (e.g.
+         * {@linkcode MIDIAccess.addEventListener|MIDIAccess's},
+         * {@linkcode MIDIInput.addEventListener|MIDIInput's},
+         * {@linkcode MIDIOutput.addEventListener|MIDIOutput's}) which can have
+         * new listeners attached. Restricted by the keys of
+         * {@linkcode TEventTypeToEventValueMap} passed in the first call
+         */
+        readonly type: TSelectedEventType;
+    };
+    /**
+     * Additional attributes that will be attached to Open Telemetry span of
+     * the stream
+     */
+    readonly spanAttributes: {
+        readonly spanTargetName: string;
+        readonly [k: string]: unknown;
+    };
+    /**
+     * The name of the field that will be extracted from the event (e.g.
+     * {@linkcode MIDIConnectionEvent.port|MIDIConnectionEvent's port},
+     * {@linkcode MIDIMessageEvent.data|MIDIMessageEvent's data})
+     */
+    readonly nullableFieldName: TNullableFieldName;
+}
+export interface StreamMakerOptionsWellknown {
+    /**
+     * A boolean value indicating that events of this type will be dispatched to
+     * the registered `listener` before being dispatched to any `EventTarget`
+     * beneath it in the DOM tree.
+     * @default false
+     */
+    readonly capture?: boolean;
+    /**
+     * A boolean value indicating that the `listener` should be invoked at most
+     * once after being added. If `true`, the `listener` would be automatically
+     * removed when invoked.
+     * @default false
+     */
+    readonly passive?: boolean;
+    /**
+     * A boolean value that, if true, indicates that the function specified by
+     * listener will never call `preventDefault()`. If a passive listener calls
+     * `preventDefault()`, nothing will happen and a console warning may be
+     * generated.
+     * @default false
+     */
+    readonly once?: boolean;
+    /**
+     * How many elements sent by event target to buffer while waiting for the
+     * moment they are consumed. Can be limited to a certain number
+     * @default "unbounded"
+     */
+    readonly bufferSize?: number | 'unbounded' | undefined;
+}
+export interface StreamMakerOptionsObject<TOnNullStrategy extends OnNullStrategy> extends StreamMakerOptionsWellknown {
+    /**
+     * A strategy to react when the MIDI-related event will have relevant field be
+     * null. Although there should be no sane scenario where it would be the case,
+     * it's still allowed by the spec, and for a better DevX this lib lets the dev
+     * make a decision on how to handle such cases.
+     *
+     * - `fail` will add an error into a signature of a stream, allowing the user
+     *   to handle it
+     * - `die` will throw a defect, which won't be reflected as a possible failure
+     *   in types. Selected by default. `undefined` is treated the same.
+     * - `ignore` will just silently remove such events from the stream
+     * - `passthrough` - will pass such events with an unmodified content of the
+     *   relevant field
+     *
+     * @default 'die'
+     */
+    readonly onExtremelyRareNullableField?: TOnNullStrategy;
+}
+/**
+ * Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export type StreamMakerOptions<TOnNullStrategy extends OnNullStrategy> = boolean | StreamMakerOptionsObject<TOnNullStrategy> | undefined;
+export type OnNullStrategy = (typeof validOnNullStrategies extends Set<infer U> ? U : never) | undefined;
+export type StreamValue<TTag extends string, TCameFrom, TContainerWithNullableFields extends object, TOnNullStrategy extends OnNullStrategy> = {
+    readonly _tag: TTag;
+    /**
+     * An effectful MIDI entity that wraps the raw MIDI object, which triggered an
+     * event
+     */
+    readonly cameFrom: TCameFrom;
+    readonly capturedAt: Date;
+} & ({
+    readonly [NullableField in keyof TContainerWithNullableFields]: Exclude<TContainerWithNullableFields[NullableField], null>;
+} | ([TOnNullStrategy] extends ['passthrough'] ? {
+    readonly [NullableField in keyof TContainerWithNullableFields]: null;
+} : never));
+export type StreamError<TOnNullStrategy extends OnNullStrategy, E> = E | ([TOnNullStrategy] extends ['fail'] ? Cause.NoSuchElementException : never);
+export interface BuiltStream<TTag extends string, TCameFrom, TContainerWithNullableFields extends object, TOnNullStrategy extends OnNullStrategy, E = never, R = never> extends Stream.Stream<StreamValue<TTag, TCameFrom, TContainerWithNullableFields, TOnNullStrategy>, StreamError<TOnNullStrategy, E>, R> {
+}
+export interface DualStreamMaker<TCameFrom, TTag extends string, TContainerWithNullableFields extends object> extends MakeStreamTargetFirst<TCameFrom, TTag, TContainerWithNullableFields>, MakeStreamTargetLast<TCameFrom, TTag, TContainerWithNullableFields> {
+}
+export interface MakeStreamTargetFirst<TCameFrom, TTag extends string, TContainerWithNullableFields extends object> {
+    /**
+     * @param polymorphicEventTargetWrapper Raw MIDI object, which triggers
+     * events, wrapped in this lib's abstraction and potentially inside Effect.
+     * Will be assigned to the `cameFrom` property of the stream's success channel
+     * object
+     *
+     * @param options Passing a value of a `boolean` type is equivalent to setting
+     * `options.capture` property
+     */
+    <E = never, R = never, const TOnNullStrategy extends OnNullStrategy = undefined>(polymorphicEventTargetWrapper: Util.PolymorphicEffect<TCameFrom, E, R>, options?: StreamMakerOptions<TOnNullStrategy>): BuiltStream<TTag, TCameFrom, TContainerWithNullableFields, TOnNullStrategy, E, R>;
+}
+export interface MakeStreamTargetLast<TCameFrom, TTag extends string, TContainerWithNullableFields extends object> {
+    /**
+     * @param options Passing a value of a `boolean` type is equivalent to setting
+     * `options.capture` property
+     *
+     * **Second call argument**
+     *
+     * - `polymorphicEventTargetWrapper` Raw MIDI object, which triggers events,
+     *   wrapped in this lib's abstraction and potentially inside Effect. Will be
+     *   assigned to the `cameFrom` property of the stream's success channel
+     *   object
+     */
+    <const TOnNullStrategy extends OnNullStrategy = undefined>(options?: StreamMakerOptions<TOnNullStrategy>): {
+        /**
+         * @param polymorphicEventTargetWrapper Raw MIDI object, which triggers
+         * events, wrapped in this lib's abstraction and potentially inside Effect.
+         * Will be assigned to the `cameFrom` property of the stream's success
+         * channel object
+         */
+        <E = never, R = never>(polymorphicEventTargetWrapper: Util.PolymorphicEffect<TCameFrom, E, R>): BuiltStream<TTag, TCameFrom, TContainerWithNullableFields, TOnNullStrategy, E, R>;
+    };
+}
+export {};
+//# sourceMappingURL=StreamMaker.d.ts.map

package/dist-types/src/internal/StreamMaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamMaker.d.ts","sourceRoot":"","sources":["../../../src/internal/StreamMaker.ts"],"names":[],"mappings":"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"}