@effect/platform 0.21.0 → 0.22.1

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

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Context = require('effect/Context');
+var Deferred = require('effect/Deferred');
+var Effect = require('effect/Effect');
+var Exit = require('effect/Exit');
+var Fiber = require('effect/Fiber');
+var Function = require('effect/Function');
+var Layer = require('effect/Layer');
+var Pool = require('effect/Pool');
+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 Context__namespace = /*#__PURE__*/_interopNamespace(Context);
+var Deferred__namespace = /*#__PURE__*/_interopNamespace(Deferred);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Exit__namespace = /*#__PURE__*/_interopNamespace(Exit);
+var Fiber__namespace = /*#__PURE__*/_interopNamespace(Fiber);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Pool__namespace = /*#__PURE__*/_interopNamespace(Pool);
+var Queue__namespace = /*#__PURE__*/_interopNamespace(Queue);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const defaultQueue = () => Effect__namespace.map(Queue__namespace.unbounded(), queue => ({
+  offer: (id, item) => Queue__namespace.offer(queue, [id, item]),
+  take: Queue__namespace.take(queue),
+  shutdown: Queue__namespace.shutdown(queue)
+}));
+
+/** @internal */
+const PlatformWorkerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/PlatformWorker");
+
+/** @internal */
+const PlatformWorker$1 = /*#__PURE__*/Context__namespace.Tag(PlatformWorkerTypeId$1);
+
+/** @internal */
+const WorkerManagerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/WorkerManager");
+
+/** @internal */
+const WorkerManager$1 = /*#__PURE__*/Context__namespace.Tag(WorkerManagerTypeId$1);
+
+/** @internal */
+const makeManager$1 = /*#__PURE__*/Effect__namespace.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__namespace.gen(function* (_) {
+        const id = idCounter++;
+        const fiberId = yield* _(Effect__namespace.fiberId);
+        let requestIdCounter = 0;
+        const readyLatch = yield* _(Deferred__namespace.make());
+        const semaphore = yield* _(Effect__namespace.makeSemaphore(permits));
+        const requestMap = new Map();
+        const outbound = queue ?? (yield* _(defaultQueue()));
+        yield* _(Effect__namespace.addFinalizer(() => outbound.shutdown));
+        const backing = yield* _(platform.spawn(spawn(id)));
+        yield* _(Effect__namespace.addFinalizer(() => Effect__namespace.zipRight(Effect__namespace.forEach(requestMap.values(), ([queue]) => Queue__namespace.shutdown(queue), {
+          discard: true
+        }), Effect__namespace.sync(() => requestMap.clear()))));
+        const handleMessage = msg => Effect__namespace.suspend(() => {
+          switch (msg[0]) {
+            case 0:
+              {
+                return Deferred__namespace.complete(readyLatch, Effect__namespace.unit);
+              }
+            case 1:
+              {
+                const response = msg[1];
+                const queue = requestMap.get(response[0]);
+                if (!queue) return Effect__namespace.unit;
+                switch (response[1]) {
+                  // data
+                  case 0:
+                    {
+                      return Queue__namespace.offer(queue[0], Exit__namespace.succeed(response[2]));
+                    }
+                  // end
+                  case 1:
+                    {
+                      return response.length === 2 ? Queue__namespace.shutdown(queue[0]) : Effect__namespace.zipRight(Queue__namespace.offer(queue[0], Exit__namespace.succeed(response[2])), Queue__namespace.shutdown(queue[0]));
+                    }
+                  // error / defect
+                  case 2:
+                  case 3:
+                    {
+                      return Effect__namespace.zipRight(Queue__namespace.offer(queue[0], response[1] === 2 ? Exit__namespace.fail(response[2]) : Exit__namespace.die(response[2])), Queue__namespace.shutdown(queue[0]));
+                    }
+                }
+              }
+          }
+        });
+        const executeAcquire = request => Effect__namespace.tap(Effect__namespace.all([Effect__namespace.sync(() => requestIdCounter++), Queue__namespace.unbounded(), Deferred__namespace.make()]), ([id, queue, deferred]) => Effect__namespace.suspend(() => {
+          requestMap.set(id, [queue, deferred]);
+          return outbound.offer(id, request);
+        }));
+        const executeRelease = ([id,, deferred], exit) => {
+          const release = Effect__namespace.zipRight(Deferred__namespace.complete(deferred, Effect__namespace.unit), Effect__namespace.sync(() => requestMap.delete(id)));
+          return Exit__namespace.isInterrupted(exit) ? Effect__namespace.zipRight(backing.send([id, 1]), release) : release;
+        };
+        const execute = request => Stream__namespace.flatMap(Stream__namespace.acquireRelease(executeAcquire(request), executeRelease), ([, queue]) => Stream__namespace.flatten(Stream__namespace.fromQueue(queue)));
+        const executeEffect = request => Effect__namespace.acquireUseRelease(executeAcquire(request), ([, queue]) => Effect__namespace.flatten(Queue__namespace.take(queue)), executeRelease);
+        const handleMessages = yield* _(Queue__namespace.take(backing.queue), Effect__namespace.flatMap(handleMessage), Effect__namespace.forever, Effect__namespace.forkDaemon);
+        yield* _(Effect__namespace.addFinalizer(() => handleMessages.interruptAsFork(fiberId)));
+        const postMessages = yield* _(semaphore.take(1), Effect__namespace.zipRight(outbound.take), Effect__namespace.flatMap(([id, request]) => Function.pipe(Effect__namespace.suspend(() => {
+          const result = requestMap.get(id);
+          if (!result) return Effect__namespace.unit;
+          const transferables = transfers(request);
+          return Effect__namespace.zipRight(backing.send([id, 0, request], transferables), Deferred__namespace.await(result[1]));
+        }), Effect__namespace.ensuring(semaphore.release(1)), Effect__namespace.fork)), Effect__namespace.forever, Effect__namespace.forkDaemon);
+        yield* _(Effect__namespace.addFinalizer(() => postMessages.interruptAsFork(fiberId)));
+        const join = Effect__namespace.race(Fiber__namespace.joinAll([handleMessages, postMessages]), backing.join);
+        return {
+          id,
+          join,
+          execute,
+          executeEffect
+        };
+      });
+    }
+  });
+});
+
+/** @internal */
+const layerManager$1 = /*#__PURE__*/Layer__namespace.effect(WorkerManager$1, makeManager$1);
+
+/** @internal */
+const makePool$1 = () => options => Effect__namespace.gen(function* (_) {
+  const manager = yield* _(WorkerManager$1);
+  const backing = yield* _("timeToLive" in options ? Pool__namespace.makeWithTTL({
+    acquire: manager.spawn(options),
+    min: options.minSize,
+    max: options.maxSize,
+    timeToLive: options.timeToLive
+  }) : Pool__namespace.make({
+    acquire: manager.spawn(options),
+    size: options.size
+  }));
+  const pool = {
+    backing,
+    execute: message => Stream__namespace.unwrap(Effect__namespace.map(Effect__namespace.scoped(backing.get()), worker => worker.execute(message))),
+    executeEffect: message => Effect__namespace.flatMap(Effect__namespace.scoped(backing.get()), worker => worker.executeEffect(message))
+  };
+  return pool;
+});
+
+/** @internal */
+const makePoolLayer$1 = managerLayer => (tag, options) => Layer__namespace.provide(managerLayer, Layer__namespace.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;
+
+exports.PlatformWorker = PlatformWorker;
+exports.PlatformWorkerTypeId = PlatformWorkerTypeId;
+exports.WorkerManager = WorkerManager;
+exports.WorkerManagerTypeId = WorkerManagerTypeId;
+exports.layerManager = layerManager;
+exports.makeManager = makeManager;
+exports.makePool = makePool;
+exports.makePoolLayer = makePoolLayer;

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";