@effect-app/vue-components 4.0.0-beta.220 → 4.0.0-beta.221

package/dist/vue-components51.es.js

@@ -1,36 +1,4 @@
-import { getGlobal as e, registerGlobal as t, unregisterGlobal as n } from "./vue-components47.es.js";
-import { DiagComponentLogger as r } from "./vue-components48.es.js";
-import { DiagLogLevel as i } from "./vue-components49.es.js";
-import { createLogLevelDiagLogger as a } from "./vue-components50.es.js";
-//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/diag.js
-var o = "diag", s = class s {
-	static instance() {
-		return this._instance ||= new s(), this._instance;
-	}
-	constructor() {
-		function s(t) {
-			return function(...n) {
-				let r = e("diag");
-				if (r) return r[t](...n);
-			};
-		}
-		let c = this;
-		c.setLogger = (n, r = { logLevel: i.INFO }) => {
-			if (n === c) {
-				let e = /* @__PURE__ */ Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-				return c.error(e.stack ?? e.message), !1;
-			}
-			typeof r == "number" && (r = { logLevel: r });
-			let o = e("diag"), s = a(r.logLevel ?? i.INFO, n);
-			if (o && !r.suppressOverrideMessage) {
-				let e = (/* @__PURE__ */ Error()).stack ?? "<failed to generate stacktrace>";
-				o.warn(`Current logger will be overwritten from ${e}`), s.warn(`Current logger will overwrite one already registered from ${e}`);
-			}
-			return t("diag", s, c, !0);
-		}, c.disable = () => {
-			n(o, c);
-		}, c.createComponentLogger = (e) => new r(e), c.verbose = s("verbose"), c.debug = s("debug"), c.info = s("info"), c.warn = s("warn"), c.error = s("error");
-	}
-};
+globalThis.RegExp;
+var e = (e) => e.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
 //#endregion
-export { s as DiagAPI };
+export { e as escape };

package/dist/vue-components52.es.js

@@ -1,18 +1,7 @@
-//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/context.js
-function e(e) {
-	return Symbol.for(e);
-}
-var t = new class e {
-	constructor(t) {
-		let n = this;
-		n._currentContext = t ? new Map(t) : /* @__PURE__ */ new Map(), n.getValue = (e) => n._currentContext.get(e), n.setValue = (t, r) => {
-			let i = new e(n._currentContext);
-			return i._currentContext.set(t, r), i;
-		}, n.deleteValue = (t) => {
-			let r = new e(n._currentContext);
-			return r._currentContext.delete(t), r;
-		};
-	}
-}();
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/internal/redacted.js
+var e = /* @__PURE__ */ new WeakMap(), t = (t) => {
+	if (e.has(t)) return e.get(t);
+	throw Error("Unable to get redacted value" + (t.label ? ` with label: "${t.label}"` : ""));
+};
 //#endregion
-export { t as ROOT_CONTEXT, e as createContextKey };
+export { e as redactedRegistry, t as value };

package/dist/vue-components53.es.js

@@ -1,21 +1,29 @@
-import { ROOT_CONTEXT as e } from "./vue-components52.es.js";
-//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
-var t = class {
-	active() {
-		return e;
+import { hasProperty as e, isString as t } from "./vue-components15.es.js";
+import { hash as n, symbol as r } from "./vue-components16.es.js";
+import { equals as i, symbol as a } from "./vue-components17.es.js";
+import { make as o } from "./vue-components18.es.js";
+import { PipeInspectableProto as s } from "./vue-components24.es.js";
+import { redactedRegistry as c, value as l } from "./vue-components52.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/Redacted.js
+var u = "~effect/data/Redacted", d = (t) => e(t, u), f = (e, t) => {
+	let n = Object.create(p);
+	return t?.label && (n.label = t.label), c.set(n, e), n;
+}, p = {
+	[u]: { _A: (e) => e },
+	label: void 0,
+	...s,
+	toJSON() {
+		return this.toString();
+	},
+	toString() {
+		return `<redacted${t(this.label) ? ":" + this.label : ""}>`;
+	},
+	[r]() {
+		return n(c.get(this));
+	},
+	[a](e) {
+		return d(e) && i(c.get(this), c.get(e));
 	}
-	with(e, t, n, ...r) {
-		return t.call(n, ...r);
-	}
-	bind(e, t) {
-		return t;
-	}
-	enable() {
-		return this;
-	}
-	disable() {
-		return this;
-	}
-};
+}, m = l, h = (e) => o((t, n) => e(m(t), m(n)));
 //#endregion
-export { t as NoopContextManager };
+export { d as isRedacted, f as make, h as makeEquivalence, m as value };

package/dist/vue-components54.es.js

@@ -1,30 +1,221 @@
-import { getGlobal as e, registerGlobal as t, unregisterGlobal as n } from "./vue-components47.es.js";
-import { DiagAPI as r } from "./vue-components51.es.js";
-import { NoopContextManager as i } from "./vue-components53.es.js";
-//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/context.js
-var a = "context", o = new i(), s = class i {
-	constructor() {}
-	static getInstance() {
-		return this._instance ||= new i(), this._instance;
+import { hasProperty as e } from "./vue-components15.es.js";
+import { format as t, formatPath as n } from "./vue-components21.es.js";
+import { isNone as r, map as i, some as a } from "./vue-components28.es.js";
+import { isReadonlyArrayNonEmpty as o, map as s } from "./vue-components30.es.js";
+import { getExpected as c } from "./vue-components49.es.js";
+import { make as l } from "./vue-components53.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/SchemaIssue.js
+var u = "~effect/SchemaIssue/Issue";
+function d(t) {
+	return e(t, u);
+}
+var f = class {
+	[u] = u;
+	toString() {
+		return P(this);
 	}
-	setGlobalContextManager(e) {
-		return t(a, e, r.instance());
+}, p = class extends f {
+	_tag = "Filter";
+	actual;
+	filter;
+	issue;
+	constructor(e, t, n) {
+		super(), this.actual = e, this.filter = t, this.issue = n;
 	}
-	active() {
-		return this._getContextManager().active();
+}, m = class extends f {
+	_tag = "Encoding";
+	ast;
+	actual;
+	issue;
+	constructor(e, t, n) {
+		super(), this.ast = e, this.actual = t, this.issue = n;
 	}
-	with(e, t, n, ...r) {
-		return this._getContextManager().with(e, t, n, ...r);
+}, h = class extends f {
+	_tag = "Pointer";
+	path;
+	issue;
+	constructor(e, t) {
+		super(), this.path = e, this.issue = t;
 	}
-	bind(e, t) {
-		return this._getContextManager().bind(e, t);
+}, g = class extends f {
+	_tag = "MissingKey";
+	annotations;
+	constructor(e) {
+		super(), this.annotations = e;
 	}
-	_getContextManager() {
-		return e(a) || o;
+}, _ = class extends f {
+	_tag = "UnexpectedKey";
+	ast;
+	actual;
+	constructor(e, t) {
+		super(), this.ast = e, this.actual = t;
 	}
-	disable() {
-		this._getContextManager().disable(), n(a, r.instance());
+}, v = class extends f {
+	_tag = "Composite";
+	ast;
+	actual;
+	issues;
+	constructor(e, t, n) {
+		super(), this.ast = e, this.actual = t, this.issues = n;
+	}
+}, y = class extends f {
+	_tag = "InvalidType";
+	ast;
+	actual;
+	constructor(e, t) {
+		super(), this.ast = e, this.actual = t;
+	}
+}, b = class extends f {
+	_tag = "InvalidValue";
+	actual;
+	annotations;
+	constructor(e, t) {
+		super(), this.actual = e, this.annotations = t;
+	}
+}, x = class extends f {
+	_tag = "Forbidden";
+	actual;
+	annotations;
+	constructor(e, t) {
+		super(), this.actual = e, this.annotations = t;
+	}
+}, S = class extends f {
+	_tag = "AnyOf";
+	ast;
+	actual;
+	issues;
+	constructor(e, t, n) {
+		super(), this.ast = e, this.actual = t, this.issues = n;
+	}
+}, C = class extends f {
+	_tag = "OneOf";
+	ast;
+	actual;
+	successes;
+	constructor(e, t, n) {
+		super(), this.ast = e, this.actual = t, this.successes = n;
 	}
 };
+function w(e, t) {
+	if (d(t)) return t;
+	if (typeof t == "string") return new b(a(e), { message: t });
+	let n = typeof t.issue == "string" ? new b(a(e), { message: t.issue }) : t.issue;
+	return new h(t.path, n);
+}
+function T(e, t) {
+	if (t !== void 0) return typeof t == "boolean" ? t ? void 0 : new b(a(e)) : w(e, t);
+}
+function E(e, t, n) {
+	return Array.isArray(n) ? o(n) ? n.length === 1 ? w(e, n[0]) : new v(t, a(e), s(n, (t) => w(e, t))) : void 0 : T(e, n);
+}
+var D = (e) => {
+	let n = I(e);
+	if (n !== void 0) return n;
+	switch (e._tag) {
+		case "InvalidType": return A(c(e.ast), R(e.actual));
+		case "InvalidValue": return `Invalid data ${R(e.actual)}`;
+		case "MissingKey": return "Missing key";
+		case "UnexpectedKey": return `Unexpected key with value ${t(e.actual)}`;
+		case "Forbidden": return "Forbidden operation";
+		case "OneOf": return `Expected exactly one member to match the input ${t(e.actual)}`;
+	}
+}, O = (e) => I(e.issue) ?? I(e);
+function k(e) {
+	return (t) => ({ issues: j(t, [], e?.leafHook ?? D, e?.checkHook ?? O) });
+}
+function A(e, t) {
+	return `Expected ${e}, got ${t}`;
+}
+function j(e, n, r, i) {
+	switch (e._tag) {
+		case "Filter": {
+			let a = i(e);
+			if (a !== void 0) return [{
+				path: n,
+				message: a
+			}];
+			switch (e.issue._tag) {
+				case "InvalidValue": return [{
+					path: n,
+					message: A(M(e.filter), t(e.actual))
+				}];
+				default: return j(e.issue, n, r, i);
+			}
+		}
+		case "Encoding": return j(e.issue, n, r, i);
+		case "Pointer": return j(e.issue, [...n, ...e.path], r, i);
+		case "Composite": return e.issues.flatMap((e) => j(e, n, r, i));
+		case "AnyOf": {
+			let a = I(e);
+			return e.issues.length === 0 ? a === void 0 ? [{
+				path: n,
+				message: A(c(e.ast), t(e.actual))
+			}] : [{
+				path: n,
+				message: a
+			}] : e.issues.flatMap((e) => j(e, n, r, i));
+		}
+		default: return [{
+			path: n,
+			message: r(e)
+		}];
+	}
+}
+function M(e) {
+	let t = e.annotations?.expected;
+	if (typeof t == "string") return t;
+	switch (e._tag) {
+		case "Filter": return "<filter>";
+		case "FilterGroup": return e.checks.map((e) => M(e)).join(" & ");
+	}
+}
+function N() {
+	return (e) => j(e, [], D, O).map(F).join("\n");
+}
+var P = /* @__PURE__ */ N();
+function F(e) {
+	let t = e.message;
+	if (e.path && e.path.length > 0) {
+		let r = n(e.path);
+		t += `\n  at ${r}`;
+	}
+	return t;
+}
+function I(e) {
+	switch (e._tag) {
+		case "InvalidType":
+		case "OneOf":
+		case "Composite":
+		case "AnyOf": return L(e.ast.annotations);
+		case "InvalidValue":
+		case "Forbidden": return L(e.annotations);
+		case "MissingKey": return L(e.annotations, "messageMissingKey");
+		case "UnexpectedKey": return L(e.ast.annotations, "messageUnexpectedKey");
+		case "Filter": return L(e.filter.annotations);
+		case "Encoding": return I(e.issue);
+	}
+}
+function L(e, t = "message") {
+	let n = e?.[t];
+	if (typeof n == "string") return n;
+}
+function R(e) {
+	return r(e) ? "no value provided" : t(e.value);
+}
+function z(e) {
+	switch (e._tag) {
+		case "MissingKey": return e;
+		case "Forbidden": return new x(i(e.actual, l), e.annotations);
+		case "Filter": return new p(l(e.actual), e.filter, z(e.issue));
+		case "Pointer": return new h(e.path, z(e.issue));
+		case "Encoding":
+		case "InvalidType":
+		case "InvalidValue":
+		case "Composite": return new b(i(e.actual, l));
+		case "AnyOf":
+		case "OneOf":
+		case "UnexpectedKey": return new b(a(l(e.actual)));
+	}
+}
 //#endregion
-export { s as ContextAPI };
+export { S as AnyOf, v as Composite, m as Encoding, p as Filter, x as Forbidden, y as InvalidType, b as InvalidValue, g as MissingKey, C as OneOf, h as Pointer, _ as UnexpectedKey, O as defaultCheckHook, E as make, k as makeFormatterStandardSchemaV1, z as redact };

package/dist/vue-components55.es.js

@@ -1,7 +1,85 @@
-//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
-var e;
-(function(e) {
-	e[e.NONE = 0] = "NONE", e[e.SAMPLED = 1] = "SAMPLED";
-})(e ||= {});
+import { Class as e } from "./vue-components12.es.js";
+import { isNotUndefined as t } from "./vue-components15.es.js";
+import { filter as n, isNone as r, isSome as i, map as a, match as o, some as s } from "./vue-components28.es.js";
+import { mapError as c } from "./vue-components29.es.js";
+import { fail as l, flatMapEager as u, map as d, mapEager as f, succeed as p, succeedNone as m } from "./vue-components46.es.js";
+import { make as h, toUtc as g } from "./vue-components47.es.js";
+import { decodeBase64 as _, encodeBase64 as v } from "./vue-components48.es.js";
+import { Forbidden as y, InvalidValue as b } from "./vue-components54.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/SchemaGetter.js
+var x = class t extends e {
+	run;
+	constructor(e) {
+		super(), this.run = e;
+	}
+	map(e) {
+		return new t((t, n) => this.run(t, n).pipe(f(a(e))));
+	}
+	compose(e) {
+		return T(this) ? e : T(e) ? this : new t((t, n) => this.run(t, n).pipe(u((t) => e.run(t, n))));
+	}
+};
+function S(e) {
+	return new x((t) => l(e(t)));
+}
+function C(e) {
+	return S((t) => new y(t, { message: e(t) }));
+}
+var w = /* @__PURE__ */ new x(p);
+function T(e) {
+	return e.run === w.run;
+}
+function E() {
+	return w;
+}
+function D(e) {
+	return new x((t, n) => r(t) ? m : e(t.value, n));
+}
+function O(e) {
+	return A(a(e));
+}
+function k(e) {
+	return D((t, n) => e(t, n).pipe(f(s)));
+}
+function A(e) {
+	return new x((t) => p(e(t)));
+}
+function j() {
+	return new x(() => m);
+}
+function M(e) {
+	return new x((r) => {
+		let a = n(r, t);
+		return i(a) ? p(a) : d(e, s);
+	});
+}
+function N() {
+	return O(globalThis.String);
+}
+function P() {
+	return O(globalThis.Number);
+}
+function F() {
+	return O(globalThis.BigInt);
+}
+function I() {
+	return O((e) => new globalThis.Date(e));
+}
+function L(e) {
+	let t = e?.separator ?? ",";
+	return O((e) => e === "" ? [] : e.split(t));
+}
+function R() {
+	return O(v);
+}
+function z() {
+	return k((e) => c(_(e), (t) => new b(s(e), { message: t.message })).asEffect());
+}
+function B() {
+	return k((e) => o(h(e), {
+		onNone: () => l(new b(s(e), { message: "Invalid DateTime input" })),
+		onSome: (e) => p(g(e))
+	}));
+}
 //#endregion
-export { e as TraceFlags };
+export { F as BigInt, I as Date, P as Number, N as String, B as dateTimeUtcFromInput, z as decodeBase64, R as encodeBase64, C as forbidden, j as omit, E as passthrough, L as split, O as transform, k as transformOrFail, M as withDefault };

package/dist/vue-components56.es.js

@@ -1,9 +1,74 @@
-import { TraceFlags as e } from "./vue-components55.es.js";
-//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
-var t = "0000000000000000", n = "00000000000000000000000000000000", r = {
-	traceId: n,
-	spanId: t,
-	traceFlags: e.NONE
+import { hasProperty as e } from "./vue-components15.es.js";
+import { formatDate as t } from "./vue-components21.es.js";
+import { match as n, some as r } from "./vue-components28.es.js";
+import { fail as i, succeed as a, try_ as o } from "./vue-components46.es.js";
+import { formatIso as s, make as c, toUtc as l } from "./vue-components47.es.js";
+import { InvalidValue as u } from "./vue-components54.es.js";
+import { BigInt as d, Date as f, Number as p, String as m, decodeBase64 as h, encodeBase64 as g, passthrough as _, transform as v, transformOrFail as y } from "./vue-components55.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/SchemaTransformation.js
+var b = class e {
+	_tag = "Middleware";
+	decode;
+	encode;
+	constructor(e, t) {
+		this.decode = e, this.encode = t;
+	}
+	flip() {
+		return new e(this.encode, this.decode);
+	}
+}, x = "~effect/SchemaTransformation/Transformation", S = class e {
+	[x] = x;
+	_tag = "Transformation";
+	decode;
+	encode;
+	constructor(e, t) {
+		this.decode = e, this.encode = t;
+	}
+	flip() {
+		return new e(this.encode, this.decode);
+	}
+	compose(t) {
+		return new e(this.decode.compose(t.decode), t.encode.compose(this.encode));
+	}
 };
+function C(t) {
+	return e(t, x);
+}
+var w = (e) => C(e) ? e : new S(e.decode, e.encode);
+function T(e) {
+	return new S(y(e.decode), y(e.encode));
+}
+function E(e) {
+	return new S(v(e.decode), v(e.encode));
+}
+var D = /* @__PURE__ */ new S(/* @__PURE__ */ _(), /* @__PURE__ */ _());
+function O() {
+	return D;
+}
+var k = /* @__PURE__ */ new S(/* @__PURE__ */ p(), /* @__PURE__ */ m()), A = /* @__PURE__ */ new S(/* @__PURE__ */ d(), /* @__PURE__ */ m()), j = /* @__PURE__ */ new S(/* @__PURE__ */ f(), /* @__PURE__ */ v(t)), M = (e) => E({
+	decode: (e) => {
+		let t = Error(e.message);
+		return typeof e.name == "string" && e.name !== "Error" && (t.name = e.name), typeof e.stack == "string" && (t.stack = e.stack), t;
+	},
+	encode: (t) => {
+		let n = {
+			name: t.name,
+			message: t.message
+		};
+		return e?.includeStack && typeof t.stack == "string" && (n.stack = t.stack), n;
+	}
+}), N = /* @__PURE__ */ T({
+	decode: (e) => o({
+		try: () => new URL(e),
+		catch: () => new u(r(e), { message: `Invalid URL string: ${e}` })
+	}),
+	encode: (e) => a(e.href)
+}), P = /* @__PURE__ */ new S(/* @__PURE__ */ h(), /* @__PURE__ */ g()), F = /* @__PURE__ */ T({
+	decode: (e) => n(c(e), {
+		onNone: () => i(new u(r(e), { message: `Invalid UTC DateTime string: ${e}` })),
+		onSome: (e) => a(l(e))
+	}),
+	encode: (e) => a(s(e))
+});
 //#endregion
-export { t as INVALID_SPANID, r as INVALID_SPAN_CONTEXT, n as INVALID_TRACEID };
+export { b as Middleware, S as Transformation, A as bigintFromString, j as dateFromString, F as dateTimeUtcFromString, M as errorFromErrorJsonEncoded, w as make, k as numberFromString, O as passthrough, E as transform, T as transformOrFail, P as uint8ArrayFromBase64String, N as urlFromString };