@dxos/effect 0.8.4-main.fbb7a13 → 0.8.4-main.fcc0d83b33

package/dist/lib/browser/index.mjs

@@ -10,16 +10,14 @@ import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import { invariant } from "@dxos/invariant";
 import { isNonNullable } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/common/effect/src/ast.ts";
 var reduceRefinements = (type, refinements = []) => {
   if (SchemaAST.isRefinement(type)) {
-    const annotations = type.annotations;
     const filter = type.filter;
     const nextType = {
       ...type.from,
       annotations: {
-        ...type.annotations,
-        ...annotations
+        ...type.from.annotations,
+        ...type.annotations
       }
     };
     return reduceRefinements(nextType, [
@@ -39,12 +37,23 @@ var getBaseType = (prop) => {
 };
 var getProperties = (ast) => {
   const properties = SchemaAST.getPropertySignatures(ast);
-  return properties.map((prop) => ({
-    ...getBaseType(prop),
-    name: prop.name,
-    isOptional: prop.isOptional,
-    isReadonly: prop.isReadonly
-  }));
+  return properties.map((prop) => {
+    const { type, refinements } = getBaseType(prop);
+    const mergedType = prop.annotations && Reflect.ownKeys(prop.annotations).length > 0 ? {
+      ...type,
+      annotations: {
+        ...type.annotations,
+        ...prop.annotations
+      }
+    } : type;
+    return {
+      type: mergedType,
+      refinements,
+      name: prop.name,
+      isOptional: prop.isOptional,
+      isReadonly: prop.isReadonly
+    };
+  });
 };
 var VisitResult = /* @__PURE__ */ (function(VisitResult2) {
   VisitResult2[VisitResult2["CONTINUE"] = 0] = "CONTINUE";
@@ -141,15 +150,7 @@ var findProperty = (schema, path) => {
   const getProp = (node, path2) => {
     const [name, ...rest] = path2;
     const typeNode = findNode(node, SchemaAST.isTypeLiteral);
-    invariant(typeNode, void 0, {
-      F: __dxlog_file,
-      L: 235,
-      S: void 0,
-      A: [
-        "typeNode",
-        ""
-      ]
-    });
+    invariant(typeNode);
     for (const prop of SchemaAST.getPropertySignatures(typeNode)) {
       if (prop.name === name) {
         if (rest.length) {
@@ -163,10 +164,10 @@ var findProperty = (schema, path) => {
   return getProp(schema.ast, path.split("."));
 };
 var defaultAnnotations = {
-  ["ObjectKeyword"]: SchemaAST.objectKeyword,
-  ["StringKeyword"]: SchemaAST.stringKeyword,
-  ["NumberKeyword"]: SchemaAST.numberKeyword,
-  ["BooleanKeyword"]: SchemaAST.booleanKeyword
+  ObjectKeyword: SchemaAST.objectKeyword,
+  StringKeyword: SchemaAST.stringKeyword,
+  NumberKeyword: SchemaAST.numberKeyword,
+  BooleanKeyword: SchemaAST.booleanKeyword
 };
 var getAnnotation2 = (annotationId, noDefault = true) => (node) => {
   const id = Function.pipe(SchemaAST.getIdentifierAnnotation(node), Option.getOrUndefined);
@@ -197,6 +198,12 @@ var isOption = (node) => {
 var isLiteralUnion = (node) => {
   return SchemaAST.isUnion(node) && node.types.every(SchemaAST.isLiteral);
 };
+var getLiteralValues = (schema) => {
+  if (!isLiteralUnion(schema.ast)) {
+    return [];
+  }
+  return schema.ast.types.map((node) => node.literal);
+};
 var isArrayType = (node) => {
   return SchemaAST.isTupleType(node) && node.elements.length === 0 && node.rest.length === 1;
 };
@@ -210,15 +217,7 @@ var isDiscriminatedUnion = (node) => {
   return SchemaAST.isUnion(node) && !!getDiscriminatingProps(node)?.length;
 };
 var getDiscriminatingProps = (node) => {
-  invariant(SchemaAST.isUnion(node), void 0, {
-    F: __dxlog_file,
-    L: 353,
-    S: void 0,
-    A: [
-      "SchemaAST.isUnion(node)",
-      ""
-    ]
-  });
+  invariant(SchemaAST.isUnion(node));
   if (isOption(node)) {
     return;
   }
@@ -228,39 +227,15 @@ var getDiscriminatingProps = (node) => {
   }, []);
 };
 var getDiscriminatedType = (node, value = {}) => {
-  invariant(SchemaAST.isUnion(node), void 0, {
-    F: __dxlog_file,
-    L: 377,
-    S: void 0,
-    A: [
-      "SchemaAST.isUnion(node)",
-      ""
-    ]
-  });
-  invariant(value, void 0, {
-    F: __dxlog_file,
-    L: 378,
-    S: void 0,
-    A: [
-      "value",
-      ""
-    ]
-  });
+  invariant(SchemaAST.isUnion(node));
+  invariant(value);
   const props = getDiscriminatingProps(node);
   if (!props?.length) {
     return;
   }
   for (const type of node.types) {
     const match = SchemaAST.getPropertySignatures(type).filter((prop) => props?.includes(prop.name.toString())).every((prop) => {
-      invariant(SchemaAST.isLiteral(prop.type), void 0, {
-        F: __dxlog_file,
-        L: 389,
-        S: void 0,
-        A: [
-          "SchemaAST.isLiteral(prop.type)",
-          ""
-        ]
-      });
+      invariant(SchemaAST.isLiteral(prop.type));
       return prop.type.literal === value[prop.name.toString()];
     });
     if (match) {
@@ -270,15 +245,7 @@ var getDiscriminatedType = (node, value = {}) => {
   const fields = Object.fromEntries(props.map((prop) => {
     const literals = node.types.map((type) => {
       const literal = SchemaAST.getPropertySignatures(type).find((p) => p.name.toString() === prop);
-      invariant(SchemaAST.isLiteral(literal.type), void 0, {
-        F: __dxlog_file,
-        L: 407,
-        S: void 0,
-        A: [
-          "SchemaAST.isLiteral(literal.type)",
-          ""
-        ]
-      });
+      invariant(SchemaAST.isLiteral(literal.type));
       return literal.type.literal;
     }).filter(isNonNullable);
     return literals.length ? [
@@ -330,8 +297,8 @@ var getIndexSignatures = (ast) => {
 };
 
 // src/atom-kvs.ts
-import * as BrowserKeyValueStore from "@effect/platform-browser/BrowserKeyValueStore";
 import { Atom } from "@effect-atom/atom-react";
+import * as BrowserKeyValueStore from "@effect/platform-browser/BrowserKeyValueStore";
 var defaultRuntime = Atom.runtime(BrowserKeyValueStore.layerLocalStorage);
 var createKvsStore = (options) => {
   const runtime2 = options.runtime ?? defaultRuntime;
@@ -346,12 +313,8 @@ var createKvsStore = (options) => {
 // src/context.ts
 import * as Effect from "effect/Effect";
 import { Context } from "@dxos/context";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/common/effect/src/context.ts";
 var contextFromScope = () => Effect.gen(function* () {
-  const ctx = new Context(void 0, {
-    F: __dxlog_file2,
-    L: 13
-  });
+  const ctx = new Context();
   yield* Effect.addFinalizer(() => Effect.promise(() => ctx.dispose()));
   return ctx;
 });
@@ -375,8 +338,7 @@ import * as Exit from "effect/Exit";
 import * as GlobalValue from "effect/GlobalValue";
 import * as Option2 from "effect/Option";
 import * as Runtime from "effect/Runtime";
-var spanSymbol = Symbol.for("effect/SpanAnnotation");
-var originalSymbol = Symbol.for("effect/OriginalAnnotation");
+var spanSymbol = /* @__PURE__ */ Symbol.for("effect/SpanAnnotation");
 var spanToTrace = GlobalValue.globalValue("effect/Tracer/spanToTrace", () => /* @__PURE__ */ new WeakMap());
 var locationRegex = /\((.*)\)/g;
 var prettyErrorStack = (error, appendStacks = []) => {
@@ -386,7 +348,7 @@ var prettyErrorStack = (error, appendStacks = []) => {
   const span = error[spanSymbol];
   const lines = typeof error.stack === "string" ? error.stack.split("\n") : [];
   const out = [];
-  let atStack = false;
+  let atStack = false, inCore = false, passedScheduler = false;
   for (let i = 0; i < lines.length; i++) {
     if (!atStack && !lines[i].startsWith("    at ")) {
       out.push(lines[i]);
@@ -403,6 +365,26 @@ var prettyErrorStack = (error, appendStacks = []) => {
     if (lines[i].includes("effect_internal_function")) {
       break;
     }
+    const filename = lines[i].match(/\/([a-zA-Z0-9_\-.]+):\d+:\d+\)$/)?.[1];
+    if (!inCore && [
+      "core-effect.ts"
+    ].includes(filename)) {
+      inCore = true;
+    }
+    if (inCore && !passedScheduler && [
+      "Scheduler.ts"
+    ].includes(filename)) {
+      passedScheduler = true;
+      continue;
+    }
+    if (passedScheduler && ![
+      "Scheduler.ts"
+    ].includes(filename)) {
+      inCore = false;
+    }
+    if (inCore) {
+      continue;
+    }
     out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>").replace(/at Arguments\./, "at "));
   }
   if (span) {
@@ -433,9 +415,7 @@ var prettyErrorStack = (error, appendStacks = []) => {
     }
   }
   out.push(...appendStacks);
-  if (error[originalSymbol]) {
-    error = error[originalSymbol];
-  }
+  error = Cause.originalError(error);
   if (error.cause) {
     error.cause = prettyErrorStack(error.cause);
   }
@@ -459,7 +439,7 @@ var causeToError = (cause) => {
     ];
     const getStackFrames = () => {
       const o = new Error();
-      Error.captureStackTrace(o, getStackFrames);
+      Error.captureStackTrace(o, causeToError);
       return o.stack.split("\n").slice(1);
     };
     const stackFrames = getStackFrames();
@@ -474,19 +454,30 @@ var causeToError = (cause) => {
 var throwCause = (cause) => {
   throw causeToError(cause);
 };
-var unwrapExit = (exit) => {
-  if (Exit.isSuccess(exit)) {
-    return exit.value;
+var unwrapExit = (exit2) => {
+  if (Exit.isSuccess(exit2)) {
+    return exit2.value;
   }
-  return throwCause(exit.cause);
+  return throwCause(exit2.cause);
 };
 var runAndForwardErrors = async (effect, options) => {
-  const exit = await Effect2.runPromiseExit(effect, options);
-  return unwrapExit(exit);
-};
-var runInRuntime = async (runtime2, effect, options) => {
-  const exit = await Runtime.runPromiseExit(runtime2, effect, options);
-  return unwrapExit(exit);
+  const exit2 = await Effect2.runPromiseExit(effect, options);
+  return unwrapExit(exit2);
+};
+var runInRuntime = (...args) => {
+  if (args.length === 1) {
+    const [runtime2] = args;
+    return async (effect, options) => {
+      const exit2 = await Runtime.runPromiseExit(runtime2, effect, options);
+      return unwrapExit(exit2);
+    };
+  } else {
+    const [runtime2, effect, options] = args;
+    return (async () => {
+      const exit2 = await Runtime.runPromiseExit(runtime2, effect, options);
+      return unwrapExit(exit2);
+    })();
+  }
 };
 var promiseWithCauseCapture = (evaluate) => Effect2.promise(async (signal) => {
   try {
@@ -591,7 +582,6 @@ import * as Schema2 from "effect/Schema";
 import { JSONPath } from "jsonpath-plus";
 import { invariant as invariant2 } from "@dxos/invariant";
 import { getDeep, setDeep } from "@dxos/util";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/common/effect/src/json-path.ts";
 var PATH_REGEX = /^($|[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*|\[\d+\](?:\.)?)*$)/;
 var PROP_REGEX = /^\w+$/;
 var JsonPath = Schema2.String.pipe(Schema2.pattern(PATH_REGEX)).annotations({
@@ -612,28 +602,12 @@ var createJsonPath = (path) => {
       return i === 0 ? p : `.${p}`;
     }
   }).join("");
-  invariant2(isJsonPath(candidatePath), `Invalid JsonPath: ${candidatePath}`, {
-    F: __dxlog_file3,
-    L: 69,
-    S: void 0,
-    A: [
-      "isJsonPath(candidatePath)",
-      "`Invalid JsonPath: ${candidatePath}`"
-    ]
-  });
+  invariant2(isJsonPath(candidatePath), `Invalid JsonPath: ${candidatePath}`);
   return candidatePath;
 };
 var fromEffectValidationPath = (effectPath) => {
   const jsonPath = effectPath.replace(/\.\[(\d+)\]/g, "[$1]");
-  invariant2(isJsonPath(jsonPath), `Invalid JsonPath: ${jsonPath}`, {
-    F: __dxlog_file3,
-    L: 80,
-    S: void 0,
-    A: [
-      "isJsonPath(jsonPath)",
-      "`Invalid JsonPath: ${jsonPath}`"
-    ]
-  });
+  invariant2(isJsonPath(jsonPath), `Invalid JsonPath: ${jsonPath}`);
   return jsonPath;
 };
 var splitJsonPath = (path) => {
@@ -677,7 +651,7 @@ import * as Function2 from "effect/Function";
 import * as Option5 from "effect/Option";
 import * as SchemaAST2 from "effect/SchemaAST";
 import { decamelize } from "@dxos/util";
-var ParamKeyAnnotationId = Symbol.for("@dxos/schema/annotation/ParamKey");
+var ParamKeyAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/ParamKey");
 var getParamKeyAnnotation = SchemaAST2.getAnnotation(ParamKeyAnnotationId);
 var ParamKeyAnnotation = (value) => (self) => self.annotations({
   [ParamKeyAnnotationId]: value
@@ -744,15 +718,78 @@ var runPromise2 = (provider) => async (effect) => {
   return unwrapExit(await effect.pipe(Runtime3.runPromiseExit(runtime2)));
 };
 var provide2 = (runtimeProvider) => (effect) => Effect5.flatMap(runtimeProvider, (runtime2) => Effect5.provide(effect, runtime2));
+
+// src/Performance.ts
+var Performance_exports = {};
+__export(Performance_exports, {
+  addTrackEntry: () => addTrackEntry
+});
+import * as Effect6 from "effect/Effect";
+var addTrackEntry = (options) => (effect) => Effect6.gen(function* () {
+  const start = performance.now();
+  const exit2 = yield* Effect6.exit(effect);
+  const resolvedOptions = typeof options === "function" ? options(exit2) : options;
+  performance.measure(resolvedOptions.name, {
+    start,
+    detail: {
+      ...resolvedOptions.detail,
+      devtools: resolvedOptions.devtools
+    }
+  });
+  return yield* exit2;
+});
+
+// src/async-task-tagging.ts
+import * as Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import { pipe as pipe3 } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Tracer from "effect/Tracer";
+var runInTask = /* @__PURE__ */ Symbol("runInTask");
+var asyncTaskTaggingLayer = () => {
+  if (Predicate.hasProperty(console, "createTask") === false) {
+    return Layer.empty;
+  }
+  const makeTracer = Effect7.gen(function* () {
+    const oldTracer = yield* Effect7.tracer;
+    return Tracer.make({
+      span: (name, ...args) => {
+        const span = oldTracer.span(name, ...args);
+        const trace = console.createTask(name);
+        span[runInTask] = (f) => trace.run(f);
+        return span;
+      },
+      context: (f, fiber) => {
+        const maybeParentSpan = Context3.getOption(Tracer.ParentSpan)(fiber.currentContext);
+        if (maybeParentSpan._tag === "None") {
+          return oldTracer.context(f, fiber);
+        }
+        const parentSpan = maybeParentSpan.value;
+        if (parentSpan._tag === "ExternalSpan") {
+          return oldTracer.context(f, fiber);
+        }
+        const span = parentSpan;
+        if (runInTask in span && typeof span[runInTask] === "function") {
+          return span[runInTask](() => oldTracer.context(f, fiber));
+        }
+        return oldTracer.context(f, fiber);
+      }
+    });
+  });
+  return pipe3(makeTracer, Effect7.map(Layer.setTracer), Layer.unwrapEffect);
+};
 export {
   dynamic_runtime_exports as DynamicRuntime,
   JsonPath,
   JsonProp,
   ParamKeyAnnotation,
+  Performance_exports as Performance,
   RuntimeProvider_exports as RuntimeProvider,
   UrlParser,
   VisitResult,
   acquireReleaseResource,
+  asyncTaskTaggingLayer,
   causeToError,
   contextFromScope,
   createJsonPath,
@@ -767,6 +804,7 @@ export {
   getDiscriminatedType,
   getDiscriminatingProps,
   getField,
+  getLiteralValues,
   getParamKeyAnnotation,
   getProperties,
   getValue,