Aktueller Stand

backend/node_modules/effect/dist/esm/internal/fiberId.js

@@ -0,0 +1,219 @@
+import * as Equal from "../Equal.js";
+import { dual, pipe } from "../Function.js";
+import { globalValue } from "../GlobalValue.js";
+import * as Hash from "../Hash.js";
+import * as HashSet from "../HashSet.js";
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js";
+import * as MutableRef from "../MutableRef.js";
+import * as Option from "../Option.js";
+import { hasProperty } from "../Predicate.js";
+/** @internal */
+const FiberIdSymbolKey = "effect/FiberId";
+/** @internal */
+export const FiberIdTypeId = /*#__PURE__*/Symbol.for(FiberIdSymbolKey);
+/** @internal */
+const OP_NONE = "None";
+/** @internal */
+const OP_RUNTIME = "Runtime";
+/** @internal */
+const OP_COMPOSITE = "Composite";
+const emptyHash = /*#__PURE__*/Hash.string(`${FiberIdSymbolKey}-${OP_NONE}`);
+/** @internal */
+class None {
+  [FiberIdTypeId] = FiberIdTypeId;
+  _tag = OP_NONE;
+  id = -1;
+  startTimeMillis = -1;
+  [Hash.symbol]() {
+    return emptyHash;
+  }
+  [Equal.symbol](that) {
+    return isFiberId(that) && that._tag === OP_NONE;
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  toJSON() {
+    return {
+      _id: "FiberId",
+      _tag: this._tag
+    };
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+/** @internal */
+class Runtime {
+  id;
+  startTimeMillis;
+  [FiberIdTypeId] = FiberIdTypeId;
+  _tag = OP_RUNTIME;
+  constructor(id, startTimeMillis) {
+    this.id = id;
+    this.startTimeMillis = startTimeMillis;
+  }
+  [Hash.symbol]() {
+    return Hash.cached(this, Hash.string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`));
+  }
+  [Equal.symbol](that) {
+    return isFiberId(that) && that._tag === OP_RUNTIME && this.id === that.id && this.startTimeMillis === that.startTimeMillis;
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  toJSON() {
+    return {
+      _id: "FiberId",
+      _tag: this._tag,
+      id: this.id,
+      startTimeMillis: this.startTimeMillis
+    };
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+/** @internal */
+class Composite {
+  left;
+  right;
+  [FiberIdTypeId] = FiberIdTypeId;
+  _tag = OP_COMPOSITE;
+  constructor(left, right) {
+    this.left = left;
+    this.right = right;
+  }
+  _hash;
+  [Hash.symbol]() {
+    return pipe(Hash.string(`${FiberIdSymbolKey}-${this._tag}`), Hash.combine(Hash.hash(this.left)), Hash.combine(Hash.hash(this.right)), Hash.cached(this));
+  }
+  [Equal.symbol](that) {
+    return isFiberId(that) && that._tag === OP_COMPOSITE && Equal.equals(this.left, that.left) && Equal.equals(this.right, that.right);
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  toJSON() {
+    return {
+      _id: "FiberId",
+      _tag: this._tag,
+      left: toJSON(this.left),
+      right: toJSON(this.right)
+    };
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+/** @internal */
+export const none = /*#__PURE__*/new None();
+/** @internal */
+export const runtime = (id, startTimeMillis) => {
+  return new Runtime(id, startTimeMillis);
+};
+/** @internal */
+export const composite = (left, right) => {
+  return new Composite(left, right);
+};
+/** @internal */
+export const isFiberId = self => hasProperty(self, FiberIdTypeId);
+/** @internal */
+export const isNone = self => {
+  return self._tag === OP_NONE || pipe(toSet(self), HashSet.every(id => isNone(id)));
+};
+/** @internal */
+export const isRuntime = self => {
+  return self._tag === OP_RUNTIME;
+};
+/** @internal */
+export const isComposite = self => {
+  return self._tag === OP_COMPOSITE;
+};
+/** @internal */
+export const combine = /*#__PURE__*/dual(2, (self, that) => {
+  if (self._tag === OP_NONE) {
+    return that;
+  }
+  if (that._tag === OP_NONE) {
+    return self;
+  }
+  return new Composite(self, that);
+});
+/** @internal */
+export const combineAll = fiberIds => {
+  return pipe(fiberIds, HashSet.reduce(none, (a, b) => combine(b)(a)));
+};
+/** @internal */
+export const getOrElse = /*#__PURE__*/dual(2, (self, that) => isNone(self) ? that : self);
+/** @internal */
+export const ids = self => {
+  switch (self._tag) {
+    case OP_NONE:
+      {
+        return HashSet.empty();
+      }
+    case OP_RUNTIME:
+      {
+        return HashSet.make(self.id);
+      }
+    case OP_COMPOSITE:
+      {
+        return pipe(ids(self.left), HashSet.union(ids(self.right)));
+      }
+  }
+};
+const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => MutableRef.make(0));
+/** @internal */
+export const make = (id, startTimeSeconds) => {
+  return new Runtime(id, startTimeSeconds);
+};
+/** @internal */
+export const threadName = self => {
+  const identifiers = Array.from(ids(self)).map(n => `#${n}`).join(",");
+  return identifiers;
+};
+/** @internal */
+export const toOption = self => {
+  const fiberIds = toSet(self);
+  if (HashSet.size(fiberIds) === 0) {
+    return Option.none();
+  }
+  let first = true;
+  let acc;
+  for (const fiberId of fiberIds) {
+    if (first) {
+      acc = fiberId;
+      first = false;
+    } else {
+      // @ts-expect-error
+      acc = pipe(acc, combine(fiberId));
+    }
+  }
+  // @ts-expect-error
+  return Option.some(acc);
+};
+/** @internal */
+export const toSet = self => {
+  switch (self._tag) {
+    case OP_NONE:
+      {
+        return HashSet.empty();
+      }
+    case OP_RUNTIME:
+      {
+        return HashSet.make(self);
+      }
+    case OP_COMPOSITE:
+      {
+        return pipe(toSet(self.left), HashSet.union(toSet(self.right)));
+      }
+  }
+};
+/** @internal */
+export const unsafeMake = () => {
+  const id = MutableRef.get(_fiberCounter);
+  pipe(_fiberCounter, MutableRef.set(id + 1));
+  return new Runtime(id, Date.now());
+};
+//# sourceMappingURL=fiberId.js.map