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

package/dist/vue-components54.es.js

@@ -0,0 +1,221 @@
+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);
+	}
+}, p = class extends f {
+	_tag = "Filter";
+	actual;
+	filter;
+	issue;
+	constructor(e, t, n) {
+		super(), this.actual = e, this.filter = t, this.issue = n;
+	}
+}, m = class extends f {
+	_tag = "Encoding";
+	ast;
+	actual;
+	issue;
+	constructor(e, t, n) {
+		super(), this.ast = e, this.actual = t, this.issue = n;
+	}
+}, h = class extends f {
+	_tag = "Pointer";
+	path;
+	issue;
+	constructor(e, t) {
+		super(), this.path = e, this.issue = t;
+	}
+}, g = class extends f {
+	_tag = "MissingKey";
+	annotations;
+	constructor(e) {
+		super(), this.annotations = e;
+	}
+}, _ = class extends f {
+	_tag = "UnexpectedKey";
+	ast;
+	actual;
+	constructor(e, t) {
+		super(), this.ast = e, this.actual = t;
+	}
+}, 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 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

@@ -0,0 +1,85 @@
+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 { 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

@@ -0,0 +1,74 @@
+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 { 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 };