@effect/platform 0.22.0 → 0.23.0

package/Worker/dist/effect-platform-Worker.esm.js

@@ -0,0 +1,252 @@
+import * as Context from 'effect/Context';
+import * as Deferred from 'effect/Deferred';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Fiber from 'effect/Fiber';
+import { pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Pool from 'effect/Pool';
+import * as Queue from 'effect/Queue';
+import * as Stream from 'effect/Stream';
+
+/** @internal */
+const defaultQueue = () => Effect.map(Queue.unbounded(), queue => ({
+  offer: (id, item) => Queue.offer(queue, [id, item]),
+  take: Queue.take(queue),
+  shutdown: Queue.shutdown(queue)
+}));
+
+/** @internal */
+const PlatformWorkerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/PlatformWorker");
+
+/** @internal */
+const PlatformWorker$1 = /*#__PURE__*/Context.Tag(PlatformWorkerTypeId$1);
+
+/** @internal */
+const WorkerManagerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/WorkerManager");
+
+/** @internal */
+const WorkerManager$1 = /*#__PURE__*/Context.Tag(WorkerManagerTypeId$1);
+
+/** @internal */
+const makeManager$1 = /*#__PURE__*/Effect.gen(function* (_) {
+  const platform = yield* _(PlatformWorker$1);
+  let idCounter = 0;
+  return WorkerManager$1.of({
+    [WorkerManagerTypeId$1]: WorkerManagerTypeId$1,
+    spawn({
+      permits = 1,
+      queue,
+      spawn,
+      transfers = _ => []
+    }) {
+      return Effect.gen(function* (_) {
+        const id = idCounter++;
+        const fiberId = yield* _(Effect.fiberId);
+        let requestIdCounter = 0;
+        const readyLatch = yield* _(Deferred.make());
+        const semaphore = yield* _(Effect.makeSemaphore(permits));
+        const requestMap = new Map();
+        const outbound = queue ?? (yield* _(defaultQueue()));
+        yield* _(Effect.addFinalizer(() => outbound.shutdown));
+        const backing = yield* _(platform.spawn(spawn(id)));
+        yield* _(Effect.addFinalizer(() => Effect.zipRight(Effect.forEach(requestMap.values(), ([queue]) => Queue.shutdown(queue), {
+          discard: true
+        }), Effect.sync(() => requestMap.clear()))));
+        const handleMessage = msg => Effect.suspend(() => {
+          switch (msg[0]) {
+            case 0:
+              {
+                return Deferred.complete(readyLatch, Effect.unit);
+              }
+            case 1:
+              {
+                const response = msg[1];
+                const queue = requestMap.get(response[0]);
+                if (!queue) return Effect.unit;
+                switch (response[1]) {
+                  // data
+                  case 0:
+                    {
+                      return Queue.offer(queue[0], Exit.succeed(response[2]));
+                    }
+                  // end
+                  case 1:
+                    {
+                      return response.length === 2 ? Queue.shutdown(queue[0]) : Effect.zipRight(Queue.offer(queue[0], Exit.succeed(response[2])), Queue.shutdown(queue[0]));
+                    }
+                  // error / defect
+                  case 2:
+                  case 3:
+                    {
+                      return Effect.zipRight(Queue.offer(queue[0], response[1] === 2 ? Exit.fail(response[2]) : Exit.die(response[2])), Queue.shutdown(queue[0]));
+                    }
+                }
+              }
+          }
+        });
+        const executeAcquire = request => Effect.tap(Effect.all([Effect.sync(() => requestIdCounter++), Queue.unbounded(), Deferred.make()]), ([id, queue, deferred]) => Effect.suspend(() => {
+          requestMap.set(id, [queue, deferred]);
+          return outbound.offer(id, request);
+        }));
+        const executeRelease = ([id,, deferred], exit) => {
+          const release = Effect.zipRight(Deferred.complete(deferred, Effect.unit), Effect.sync(() => requestMap.delete(id)));
+          return Exit.isInterrupted(exit) ? Effect.zipRight(backing.send([id, 1]), release) : release;
+        };
+        const execute = request => Stream.flatMap(Stream.acquireRelease(executeAcquire(request), executeRelease), ([, queue]) => Stream.flatten(Stream.fromQueue(queue)));
+        const executeEffect = request => Effect.acquireUseRelease(executeAcquire(request), ([, queue]) => Effect.flatten(Queue.take(queue)), executeRelease);
+        const handleMessages = yield* _(Queue.take(backing.queue), Effect.flatMap(handleMessage), Effect.forever, Effect.forkDaemon);
+        yield* _(Effect.addFinalizer(() => handleMessages.interruptAsFork(fiberId)));
+        const postMessages = yield* _(semaphore.take(1), Effect.zipRight(outbound.take), Effect.flatMap(([id, request]) => pipe(Effect.suspend(() => {
+          const result = requestMap.get(id);
+          if (!result) return Effect.unit;
+          const transferables = transfers(request);
+          return Effect.zipRight(backing.send([id, 0, request], transferables), Deferred.await(result[1]));
+        }), Effect.ensuring(semaphore.release(1)), Effect.fork)), Effect.forever, Effect.forkDaemon);
+        yield* _(Effect.addFinalizer(() => postMessages.interruptAsFork(fiberId)));
+        const join = Effect.race(Fiber.joinAll([handleMessages, postMessages]), backing.join);
+        return {
+          id,
+          join,
+          execute,
+          executeEffect
+        };
+      });
+    }
+  });
+});
+
+/** @internal */
+const layerManager$1 = /*#__PURE__*/Layer.effect(WorkerManager$1, makeManager$1);
+
+/** @internal */
+const makePool$1 = () => options => Effect.gen(function* (_) {
+  const manager = yield* _(WorkerManager$1);
+  const backing = yield* _("timeToLive" in options ? Pool.makeWithTTL({
+    acquire: manager.spawn(options),
+    min: options.minSize,
+    max: options.maxSize,
+    timeToLive: options.timeToLive
+  }) : Pool.make({
+    acquire: manager.spawn(options),
+    size: options.size
+  }));
+  const pool = {
+    backing,
+    execute: message => Stream.unwrap(Effect.map(Effect.scoped(backing.get()), worker => worker.execute(message))),
+    executeEffect: message => Effect.flatMap(Effect.scoped(backing.get()), worker => worker.executeEffect(message))
+  };
+  return pool;
+});
+
+/** @internal */
+const makePoolLayer$1 = managerLayer => (tag, options) => Layer.provide(managerLayer, Layer.scoped(tag, makePool$1()(options)));
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const PlatformWorkerTypeId = PlatformWorkerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const PlatformWorker = PlatformWorker$1;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const WorkerManagerTypeId = WorkerManagerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const WorkerManager = WorkerManager$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makeManager = makeManager$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layerManager = layerManager$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makePool = makePool$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makePoolLayer = makePoolLayer$1;
+
+export { PlatformWorker, PlatformWorkerTypeId, WorkerManager, WorkerManagerTypeId, layerManager, makeManager, makePool, makePoolLayer };

package/Worker/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/effect-platform-Worker.cjs.js",
+  "module": "dist/effect-platform-Worker.esm.js"
+}

package/WorkerError/dist/effect-platform-WorkerError.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/WorkerError.js";
+//# sourceMappingURL=effect-platform-WorkerError.cjs.d.mts.map

package/WorkerError/dist/effect-platform-WorkerError.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-platform-WorkerError.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/WorkerError.d.ts"],"names":[],"mappings":"AAAA"}

package/WorkerError/dist/effect-platform-WorkerError.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/WorkerError";
+//# sourceMappingURL=effect-platform-WorkerError.cjs.d.ts.map

package/WorkerError/dist/effect-platform-WorkerError.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-platform-WorkerError.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/WorkerError.d.ts"],"names":[],"mappings":"AAAA"}

package/WorkerError/dist/effect-platform-WorkerError.cjs.dev.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Data = require('effect/Data');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Data__namespace = /*#__PURE__*/_interopNamespace(Data);
+
+/** @internal */
+const WorkerErrorTypeId$1 = /*#__PURE__*/Symbol.for("@effect-ts/platform/Worker/WorkerError");
+
+/** @internal */
+const WorkerError$1 = (reason, error) => Data__namespace.struct({
+  [WorkerErrorTypeId$1]: WorkerErrorTypeId$1,
+  _tag: "WorkerError",
+  reason,
+  error
+});
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const WorkerErrorTypeId = WorkerErrorTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+const WorkerError = WorkerError$1;
+
+exports.WorkerError = WorkerError;
+exports.WorkerErrorTypeId = WorkerErrorTypeId;

package/WorkerError/dist/effect-platform-WorkerError.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./effect-platform-WorkerError.cjs.prod.js");
+} else {
+  module.exports = require("./effect-platform-WorkerError.cjs.dev.js");
+}

package/WorkerError/dist/effect-platform-WorkerError.cjs.mjs

@@ -0,0 +1,4 @@
+export {
+  WorkerError,
+  WorkerErrorTypeId
+} from "./effect-platform-WorkerError.cjs.js";

package/WorkerError/dist/effect-platform-WorkerError.cjs.prod.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Data = require('effect/Data');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Data__namespace = /*#__PURE__*/_interopNamespace(Data);
+
+/** @internal */
+const WorkerErrorTypeId$1 = /*#__PURE__*/Symbol.for("@effect-ts/platform/Worker/WorkerError");
+
+/** @internal */
+const WorkerError$1 = (reason, error) => Data__namespace.struct({
+  [WorkerErrorTypeId$1]: WorkerErrorTypeId$1,
+  _tag: "WorkerError",
+  reason,
+  error
+});
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const WorkerErrorTypeId = WorkerErrorTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+const WorkerError = WorkerError$1;
+
+exports.WorkerError = WorkerError;
+exports.WorkerErrorTypeId = WorkerErrorTypeId;

package/WorkerError/dist/effect-platform-WorkerError.esm.js

@@ -0,0 +1,40 @@
+import * as Data from 'effect/Data';
+
+/** @internal */
+const WorkerErrorTypeId$1 = /*#__PURE__*/Symbol.for("@effect-ts/platform/Worker/WorkerError");
+
+/** @internal */
+const WorkerError$1 = (reason, error) => Data.struct({
+  [WorkerErrorTypeId$1]: WorkerErrorTypeId$1,
+  _tag: "WorkerError",
+  reason,
+  error
+});
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const WorkerErrorTypeId = WorkerErrorTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+const WorkerError = WorkerError$1;
+
+export { WorkerError, WorkerErrorTypeId };

package/WorkerError/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/effect-platform-WorkerError.cjs.js",
+  "module": "dist/effect-platform-WorkerError.esm.js"
+}

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/WorkerRunner.js";
+//# sourceMappingURL=effect-platform-WorkerRunner.cjs.d.mts.map

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-platform-WorkerRunner.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/WorkerRunner.d.ts"],"names":[],"mappings":"AAAA"}

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/WorkerRunner";
+//# sourceMappingURL=effect-platform-WorkerRunner.cjs.d.ts.map

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-platform-WorkerRunner.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/WorkerRunner.d.ts"],"names":[],"mappings":"AAAA"}

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.dev.js

@@ -0,0 +1,129 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Cause = require('effect/Cause');
+var Context = require('effect/Context');
+var Effect = require('effect/Effect');
+var Either = require('effect/Either');
+var Fiber = require('effect/Fiber');
+var Function = require('effect/Function');
+var Queue = require('effect/Queue');
+var Stream = require('effect/Stream');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Cause__namespace = /*#__PURE__*/_interopNamespace(Cause);
+var Context__namespace = /*#__PURE__*/_interopNamespace(Context);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Either__namespace = /*#__PURE__*/_interopNamespace(Either);
+var Fiber__namespace = /*#__PURE__*/_interopNamespace(Fiber);
+var Queue__namespace = /*#__PURE__*/_interopNamespace(Queue);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const PlatformRunnerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Runner/PlatformRunner");
+
+/** @internal */
+const PlatformRunner$1 = /*#__PURE__*/Context__namespace.Tag(PlatformRunnerTypeId$1);
+
+/** @internal */
+const make$1 = (process, options) => Effect__namespace.gen(function* (_) {
+  const platform = yield* _(PlatformRunner$1);
+  const backing = yield* _(platform.start());
+  const fiberMap = new Map();
+  const handleRequests = Function.pipe(Queue__namespace.take(backing.queue), Effect__namespace.tap(req => {
+    const id = req[0];
+    if (req[1] === 1) {
+      const fiber = fiberMap.get(id);
+      if (!fiber) return Effect__namespace.unit;
+      return Fiber__namespace.interrupt(fiber);
+    }
+    const stream = process(req[2]);
+    const effect = Effect__namespace.isEffect(stream) ? Effect__namespace.matchCauseEffect(stream, {
+      onFailure: cause => Either__namespace.match(Cause__namespace.failureOrCause(cause), {
+        onLeft: error => backing.send([id, 2, error]),
+        onRight: cause => backing.send([id, 3, Cause__namespace.squash(cause)])
+      }),
+      onSuccess: data => backing.send([id, 1, data])
+    }) : Function.pipe(stream, Stream__namespace.tap(item => backing.send([id, 0, item], options?.transfers ? options.transfers(item) : undefined)), Stream__namespace.runDrain, Effect__namespace.matchCauseEffect({
+      onFailure: cause => Either__namespace.match(Cause__namespace.failureOrCause(cause), {
+        onLeft: error => backing.send([id, 2, error]),
+        onRight: cause => backing.send([id, 3, Cause__namespace.squash(cause)])
+      }),
+      onSuccess: () => backing.send([id, 1])
+    }));
+    return Function.pipe(effect, Effect__namespace.ensuring(Effect__namespace.sync(() => fiberMap.delete(id))), Effect__namespace.fork, Effect__namespace.tap(fiber => Effect__namespace.sync(() => fiberMap.set(id, fiber))));
+  }), Effect__namespace.forever);
+  return yield* _(Effect__namespace.all([handleRequests, Fiber__namespace.join(backing.fiber)], {
+    concurrency: "unbounded",
+    discard: true
+  }));
+});
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const PlatformRunnerTypeId = PlatformRunnerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const PlatformRunner = PlatformRunner$1;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+exports.PlatformRunner = PlatformRunner;
+exports.PlatformRunnerTypeId = PlatformRunnerTypeId;
+exports.make = make;

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./effect-platform-WorkerRunner.cjs.prod.js");
+} else {
+  module.exports = require("./effect-platform-WorkerRunner.cjs.dev.js");
+}

package/WorkerRunner/dist/effect-platform-WorkerRunner.cjs.mjs

@@ -0,0 +1,5 @@
+export {
+  PlatformRunner,
+  PlatformRunnerTypeId,
+  make
+} from "./effect-platform-WorkerRunner.cjs.js";