@effect-app/vue-components 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/vue-components.es48.js

@@ -1,33 +1,316 @@
-import { hasProperty as c } from "./vue-components.es38.js";
-import { passthrough as t, Number as d, String as a } from "./vue-components.es45.js";
-const n = "~effect/SchemaTransformation/Transformation";
-class o {
-  [n] = n;
-  _tag = "Transformation";
-  decode;
-  encode;
-  constructor(r, s) {
-    this.decode = r, this.encode = s;
+import { format as u, formatPath as _ } from "./vue-components.es41.js";
+import { getExpected as h } from "./vue-components.es74.js";
+import { some as d, isNone as v } from "./vue-components.es24.js";
+import { hasProperty as O } from "./vue-components.es45.js";
+const g = "~effect/SchemaIssue/Issue";
+function F(t) {
+  return O(t, g);
+}
+class a {
+  [g] = g;
+  toString() {
+    return K(this);
+  }
+}
+class b extends a {
+  _tag = "Filter";
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  /**
+   * The filter that failed.
+   */
+  filter;
+  /**
+   * The issue that occurred.
+   */
+  issue;
+  constructor(e, s, n) {
+    super(), this.actual = e, this.filter = s, this.issue = n;
+  }
+}
+class A extends a {
+  _tag = "Encoding";
+  /**
+   * The schema that caused the issue.
+   */
+  ast;
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  /**
+   * The issue that occurred.
+   */
+  issue;
+  constructor(e, s, n) {
+    super(), this.ast = e, this.actual = s, this.issue = n;
+  }
+}
+class M extends a {
+  _tag = "Pointer";
+  /**
+   * The path to the location in the input that caused the issue.
+   */
+  path;
+  /**
+   * The issue that occurred.
+   */
+  issue;
+  constructor(e, s) {
+    super(), this.path = e, this.issue = s;
+  }
+}
+class P extends a {
+  _tag = "MissingKey";
+  /**
+   * The metadata for the issue.
+   */
+  annotations;
+  constructor(e) {
+    super(), this.annotations = e;
+  }
+}
+class T extends a {
+  _tag = "UnexpectedKey";
+  /**
+   * The schema that caused the issue.
+   */
+  ast;
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  constructor(e, s) {
+    super(), this.ast = e, this.actual = s;
+  }
+}
+class S extends a {
+  _tag = "Composite";
+  /**
+   * The schema that caused the issue.
+   */
+  ast;
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  /**
+   * The issues that occurred.
+   */
+  issues;
+  constructor(e, s, n) {
+    super(), this.ast = e, this.actual = s, this.issues = n;
+  }
+}
+class D extends a {
+  _tag = "InvalidType";
+  /**
+   * The schema that caused the issue.
+   */
+  ast;
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  constructor(e, s) {
+    super(), this.ast = e, this.actual = s;
+  }
+}
+class f extends a {
+  _tag = "InvalidValue";
+  /**
+   * The value that caused the issue.
+   */
+  actual;
+  /**
+   * The metadata for the issue.
+   */
+  annotations;
+  constructor(e, s) {
+    super(), this.actual = e, this.annotations = s;
+  }
+}
+class j extends a {
+  _tag = "AnyOf";
+  /**
+   * The schema that caused the issue.
+   */
+  ast;
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  /**
+   * The issues that occurred.
+   */
+  issues;
+  constructor(e, s, n) {
+    super(), this.ast = e, this.actual = s, this.issues = n;
+  }
+}
+class B extends a {
+  _tag = "OneOf";
+  /**
+   * The schema that caused the issue.
+   */
+  ast;
+  /**
+   * The input value that caused the issue.
+   */
+  actual;
+  /**
+   * The schemas that were successful.
+   */
+  successes;
+  constructor(e, s, n) {
+    super(), this.ast = e, this.actual = s, this.successes = n;
+  }
+}
+function G(t, e) {
+  if (F(e))
+    return e;
+  if (e !== void 0)
+    return typeof e == "boolean" ? e ? void 0 : new f(d(t)) : typeof e == "string" ? new f(d(t), {
+      message: e
+    }) : new M(e.path, new f(d(t), {
+      message: e.message
+    }));
+}
+const y = (t) => {
+  const e = o(t);
+  if (e !== void 0) return e;
+  switch (t._tag) {
+    case "InvalidType":
+      return p(h(t.ast), m(t.actual));
+    case "InvalidValue":
+      return `Invalid data ${m(t.actual)}`;
+    case "MissingKey":
+      return "Missing key";
+    case "UnexpectedKey":
+      return `Unexpected key with value ${u(t.actual)}`;
+    case "Forbidden":
+      return "Forbidden operation";
+    case "OneOf":
+      return `Expected exactly one member to match the input ${u(t.actual)}`;
   }
-  flip() {
-    return new o(this.encode, this.decode);
+}, x = (t) => o(t.issue) ?? o(t);
+function L(t) {
+  return (e) => ({
+    issues: i(e, [], y, x)
+  });
+}
+function p(t, e) {
+  return `Expected ${t}, got ${e}`;
+}
+function i(t, e, s, n) {
+  switch (t._tag) {
+    case "Filter": {
+      const r = n(t);
+      return r !== void 0 ? [{
+        path: e,
+        message: r
+      }] : t.issue._tag === "InvalidValue" ? [{
+        path: e,
+        message: p(I(t.filter), u(t.actual))
+      }] : i(t.issue, e, s, n);
+    }
+    case "Encoding":
+      return i(t.issue, e, s, n);
+    case "Pointer":
+      return i(t.issue, [...e, ...t.path], s, n);
+    case "Composite":
+      return t.issues.flatMap((r) => i(r, e, s, n));
+    case "AnyOf": {
+      const r = o(t);
+      if (t.issues.length === 0) {
+        if (r !== void 0) return [{
+          path: e,
+          message: r
+        }];
+        const l = p(h(t.ast), u(t.actual));
+        return [{
+          path: e,
+          message: l
+        }];
+      }
+      return t.issues.flatMap((l) => i(l, e, s, n));
+    }
+    default:
+      return [{
+        path: e,
+        message: s(t)
+      }];
+  }
+}
+function I(t) {
+  const e = t.annotations?.expected;
+  if (typeof e == "string") return e;
+  switch (t._tag) {
+    case "Filter":
+      return "<filter>";
+    case "FilterGroup":
+      return t.checks.map((s) => I(s)).join(" & ");
   }
-  compose(r) {
-    return new o(this.decode.compose(r.decode), r.encode.compose(this.encode));
+}
+function w() {
+  return (t) => i(t, [], y, x).map(E).join(`
+`);
+}
+const K = /* @__PURE__ */ w();
+function E(t) {
+  let e = t.message;
+  if (t.path && t.path.length > 0) {
+    const s = _(t.path);
+    e += `
+  at ${s}`;
+  }
+  return e;
+}
+function o(t) {
+  switch (t._tag) {
+    case "InvalidType":
+    case "OneOf":
+    case "Composite":
+    case "AnyOf":
+      return c(t.ast.annotations);
+    case "InvalidValue":
+    case "Forbidden":
+      return c(t.annotations);
+    case "MissingKey":
+      return c(t.annotations, "messageMissingKey");
+    case "UnexpectedKey":
+      return c(t.ast.annotations, "messageUnexpectedKey");
+    case "Filter":
+      return c(t.filter.annotations);
+    case "Encoding":
+      return o(t.issue);
   }
 }
-function h(e) {
-  return c(e, n);
+function c(t, e = "message") {
+  const s = t?.[e];
+  if (typeof s == "string") return s;
 }
-const f = (e) => h(e) ? e : new o(e.decode, e.encode), i = /* @__PURE__ */ new o(/* @__PURE__ */ t(), /* @__PURE__ */ t());
-function p() {
-  return i;
+function m(t) {
+  return v(t) ? "no value provided" : u(t.value);
 }
-const g = /* @__PURE__ */ new o(/* @__PURE__ */ d(), /* @__PURE__ */ a());
 export {
-  o as Transformation,
-  h as isTransformation,
-  f as make,
-  g as numberFromString,
-  p as passthrough
+  j as AnyOf,
+  S as Composite,
+  A as Encoding,
+  b as Filter,
+  D as InvalidType,
+  f as InvalidValue,
+  P as MissingKey,
+  B as OneOf,
+  M as Pointer,
+  T as UnexpectedKey,
+  x as defaultCheckHook,
+  K as defaultFormatter,
+  y as defaultLeafHook,
+  F as isIssue,
+  G as make,
+  w as makeFormatterDefault,
+  L as makeFormatterStandardSchemaV1
 };

package/dist/vue-components.es49.js

@@ -1,4 +1,33 @@
-const o = (a) => a;
+import { hasProperty as c } from "./vue-components.es45.js";
+import { passthrough as t, Number as d, String as a } from "./vue-components.es47.js";
+const n = "~effect/SchemaTransformation/Transformation";
+class o {
+  [n] = n;
+  _tag = "Transformation";
+  decode;
+  encode;
+  constructor(r, s) {
+    this.decode = r, this.encode = s;
+  }
+  flip() {
+    return new o(this.encode, this.decode);
+  }
+  compose(r) {
+    return new o(this.decode.compose(r.decode), r.encode.compose(this.encode));
+  }
+}
+function h(e) {
+  return c(e, n);
+}
+const f = (e) => h(e) ? e : new o(e.decode, e.encode), i = /* @__PURE__ */ new o(/* @__PURE__ */ t(), /* @__PURE__ */ t());
+function p() {
+  return i;
+}
+const g = /* @__PURE__ */ new o(/* @__PURE__ */ d(), /* @__PURE__ */ a());
 export {
-  o as lambda
+  o as Transformation,
+  h as isTransformation,
+  f as make,
+  g as numberFromString,
+  p as passthrough
 };

package/dist/vue-components.es5.js

@@ -1,6 +1,6 @@
 import { defineComponent as v, mergeModels as C, useModel as k, useSlots as V, computed as _, resolveComponent as g, createBlock as y, openBlock as B, unref as a, createSlots as E, withCtx as u, renderSlot as d, renderList as M, normalizeProps as S, guardReactiveProps as w } from "vue";
 import { useOnClose as L } from "./vue-components.es11.js";
-import { onMountedWithCleanup as h } from "./vue-components.es35.js";
+import { onMountedWithCleanup as h } from "./vue-components.es16.js";
 const z = /* @__PURE__ */ v({
   __name: "Dialog",
   props: /* @__PURE__ */ C({

package/dist/vue-components.es50.js

@@ -1,4 +1,6 @@
-import f from "./vue-components.es24.js";
+import { exitGetSuccess as s, exitIsSuccess as c } from "./vue-components.es43.js";
+const t = c, o = s;
 export {
-  f as default
+  o as getSuccess,
+  t as isSuccess
 };

package/dist/vue-components.es51.js

@@ -1,4 +1,26 @@
-import f from "./vue-components.es25.js";
+import { pipeArguments as s } from "./vue-components.es44.js";
+import { appendChecks as i, annotateKey as m, annotate as o } from "./vue-components.es17.js";
+import { makeUnsafe as c, makeOption as h } from "./vue-components.es53.js";
+const r = "~effect/Schema/Schema", u = {
+  [r]: r,
+  pipe() {
+    return s(this, arguments);
+  },
+  annotate(t) {
+    return this.rebuild(o(this.ast, t));
+  },
+  annotateKey(t) {
+    return this.rebuild(m(this.ast, t));
+  },
+  check(...t) {
+    return this.rebuild(i(this.ast, t));
+  }
+};
+function p(t, a) {
+  const e = Object.create(u);
+  return a && Object.assign(e, a), e.ast = t, e.rebuild = (n) => p(n, a), e.makeUnsafe = c(e), e.makeOption = h(e), e;
+}
 export {
-  f as default
+  r as TypeId,
+  p as make
 };

package/dist/vue-components.es52.js

@@ -1,113 +1,77 @@
-import { defineComponent as _, getCurrentInstance as V, computed as B, createBlock as i, openBlock as e, Transition as x, withCtx as u, createElementBlock as o, createCommentVNode as p, renderSlot as g, normalizeProps as b, guardReactiveProps as I, resolveDynamicComponent as f, unref as d, normalizeClass as v, createElementVNode as n, toDisplayString as a, Fragment as y, renderList as w, createTextVNode as C } from "vue";
-import { useIntl as L } from "./vue-components.es3.js";
-const M = {
-  key: 0,
-  class: "error-alert"
-}, j = { class: "container" }, D = {
-  key: 0,
-  viewBox: "0 0 24 24",
-  fill: "none",
-  xmlns: "http://www.w3.org/2000/svg"
-}, N = { class: "text-h6" }, z = {
-  key: 0,
-  class: "error-list"
-}, G = ["for"], H = { key: 1 }, T = /* @__PURE__ */ _({
-  __name: "OmegaErrorsInternal",
-  props: {
-    generalErrors: {},
-    errors: {},
-    hideErrorDetails: { type: Boolean }
-  },
-  setup(s) {
-    const c = V()?.appContext.components.VAlert, h = s, { trans: E } = L(), m = B(() => h.generalErrors ? h.generalErrors.filter((l) => !!l).flatMap(
-      (l) => Object.values(l).filter((t) => !!t).flatMap(
-        (t) => t.filter(
-          (r) => typeof r?.message == "string"
-        ).map((r) => r.message)
-      )
-    ) : []);
-    return (l, t) => (e(), i(x, null, {
-      default: u(() => [
-        s.errors.length || m.value.length ? (e(), o("div", M, [
-          g(l.$slots, "default", b(I({ errors: s.errors, showedGeneralErrors: m.value })), () => [
-            (e(), i(f(d(c) ? "v-alert" : "div"), {
-              class: v([d(c) ? "mb-4" : "error-alert-content", "mb-4"]),
-              type: "error",
-              variant: "tonal",
-              role: "alert",
-              "aria-live": "polite"
-            }, {
-              default: u(() => [
-                n("div", j, [
-                  g(l.$slots, "icon", {}, () => [
-                    d(c) ? p("", !0) : (e(), o("svg", D, [...t[0] || (t[0] = [
-                      n("path", {
-                        d: "M16 2H8L2 8V16L8 22H16L22 16V8L16 2Z",
-                        stroke: "currentColor",
-                        "stroke-width": "2",
-                        "stroke-linecap": "round",
-                        "stroke-linejoin": "round"
-                      }, null, -1),
-                      n("path", {
-                        d: "M12 8V12",
-                        stroke: "currentColor",
-                        "stroke-width": "2",
-                        "stroke-linecap": "round",
-                        "stroke-linejoin": "round"
-                      }, null, -1),
-                      n("path", {
-                        d: "M12 16.0195V16",
-                        stroke: "currentColor",
-                        "stroke-width": "2",
-                        "stroke-linecap": "round",
-                        "stroke-linejoin": "round"
-                      }, null, -1)
-                    ])]))
-                  ], !0),
-                  n("div", null, [
-                    n("div", N, a(d(E)("form.includes_error")) + ": ", 1),
-                    s.errors.length ? (e(), o("ul", z, [
-                      (e(!0), o(y, null, w(s.errors, (r) => (e(), o("li", {
-                        key: r.inputId,
-                        class: "error-item"
-                      }, [
-                        n("div", null, [
-                          n("label", {
-                            for: r.inputId,
-                            class: "error-link"
-                          }, a(r.label), 9, G),
-                          t[1] || (t[1] = C(" " + a(" ") + " ", -1)),
-                          s.hideErrorDetails ? p("", !0) : (e(), o("div", {
-                            key: 0,
-                            class: v(["error-message", r.errors.length < 2 && "single-error"])
-                          }, [
-                            (e(), i(f(r.errors.length > 1 ? "ul" : "div"), { class: "error-list" }, {
-                              default: u(() => [
-                                (e(!0), o(y, null, w(r.errors, (k) => (e(), i(f(r.errors.length > 1 ? "li" : "span"), { key: k }, {
-                                  default: u(() => [
-                                    C(a(k), 1)
-                                  ]),
-                                  _: 2
-                                }, 1024))), 128))
-                              ]),
-                              _: 2
-                            }, 1024))
-                          ], 2))
-                        ])
-                      ]))), 128))
-                    ])) : (e(), o("span", H, a(m.value[0]), 1))
-                  ])
-                ])
-              ]),
-              _: 3
-            }, 8, ["class"]))
-          ], !0)
-        ])) : p("", !0)
-      ]),
-      _: 3
-    }));
+import { Reference as l } from "./vue-components.es69.js";
+const o = /* @__PURE__ */ l("effect/Scheduler", {
+  defaultValue: () => new h()
+}), d = "setImmediate" in globalThis ? (u) => {
+  const e = globalThis.setImmediate(u);
+  return () => globalThis.clearImmediate(e);
+} : (u) => {
+  const e = setTimeout(u, 0);
+  return () => clearTimeout(e);
+};
+class r {
+  buckets = [];
+  scheduleTask(e, t) {
+    const s = this.buckets, n = s.length;
+    let c, i = 0;
+    for (; i < n && !(s[i][0] > t); i++)
+      c = s[i];
+    c && c[0] === t ? c[1].push(e) : i === n ? s.push([t, [e]]) : s.splice(i, 0, [t, [e]]);
+  }
+  drain() {
+    const e = this.buckets;
+    return this.buckets = [], e;
+  }
+}
+class h {
+  tasks = /* @__PURE__ */ new r();
+  running = void 0;
+  executionMode;
+  setImmediate;
+  constructor(e = "async", t = d) {
+    this.executionMode = e, this.setImmediate = t;
+  }
+  /**
+   * @since 2.0.0
+   */
+  scheduleTask(e, t) {
+    this.tasks.scheduleTask(e, t), this.running === void 0 && (this.running = this.setImmediate(this.afterScheduled));
+  }
+  /**
+   * @since 2.0.0
+   */
+  afterScheduled = () => {
+    this.running = void 0, this.runTasks();
+  };
+  /**
+   * @since 2.0.0
+   */
+  runTasks() {
+    const e = this.tasks.drain();
+    for (let t = 0; t < e.length; t++) {
+      const s = e[t][1];
+      for (let n = 0; n < s.length; n++)
+        s[n]();
+    }
+  }
+  /**
+   * @since 2.0.0
+   */
+  shouldYield(e) {
+    return e.currentOpCount >= e.maxOpsBeforeYield;
+  }
+  /**
+   * @since 2.0.0
+   */
+  flush() {
+    for (; this.tasks.buckets.length > 0; )
+      this.running !== void 0 && (this.running(), this.running = void 0), this.runTasks();
   }
+}
+const f = /* @__PURE__ */ l("effect/Scheduler/MaxOpsBeforeYield", {
+  defaultValue: () => 2048
 });
 export {
-  T as default
+  f as MaxOpsBeforeYield,
+  h as MixedScheduler,
+  o as Scheduler
 };