@atolljs/core 0.1.1 → 0.1.3

package/dist/index3.js

@@ -1,27 +1,204 @@
-import { array as e, bigint as t, boolean as n, float32 as r, float64 as i, instanceof as a, int32 as o, int64 as s, number as c, object as l, string as u, uint32 as d, uint64 as f, unknown as p } from "zod";
-import { $ZodArray as m, $ZodObject as h, $ZodString as g, $ZodType as _ } from "zod/v4/core";
 //#region src/contract/zod.ts
-var v = {
-	number: c,
-	string: u,
-	boolean: n,
-	bigint: t,
-	object: l,
-	array: e,
-	instanceof: a,
-	unknown: p,
-	int32: o,
-	uint32: d,
-	float32: r,
-	float64: i,
-	int64: s,
-	uint64: f,
-	ZodType: _,
-	ZodObject: h,
-	ZodArray: m,
-	ZodString: g
+var e = (e, t) => ({
+	_zod: { def: e },
+	evaluate: t
+}), t = -2147483648, n = 2147483647, r = () => e({
+	check: "number_format",
+	format: "safeint"
+}, (e) => Number.isInteger(e) || "expected an integer"), i = (t) => e({
+	check: "greater_than",
+	value: t,
+	inclusive: !0
+}, (e) => e >= t || `expected >= ${t}`), a = (t) => e({
+	check: "less_than",
+	value: t,
+	inclusive: !0
+}, (e) => e <= t || `expected <= ${t}`), o = () => i(0), s = (t, n) => e({ check: "custom" }, (e) => !!t(e) || (n ?? "failed custom check")), c = (t) => e({
+	check: "length_equals",
+	length: t
+}, (e) => e.length === t || `expected exactly ${t} items`), l = (t) => e({
+	check: "max_length",
+	maximum: t
+}, (e) => e.length <= t || `expected <=${t} items`), u = (t) => e({
+	check: "min_length",
+	minimum: t
+}, (e) => e.length >= t || `expected >=${t} items`), d = (t, n, r) => e({
+	check: "number_format",
+	format: t
+}, (e) => Number.isInteger(e) && e >= n && e <= r || `expected a ${t}`), f = (t, n, r) => e({
+	check: "bigint_format",
+	format: t
+}, (e) => e >= n && e <= r || `expected a ${t}`), p = /* @__PURE__ */ new WeakMap(), m = {
+	add(e, t) {
+		p.set(e, t);
+	},
+	get(e) {
+		return p.get(e);
+	}
+}, h = class extends Error {
+	name = "SchemaError";
+}, g = class {
+	_zod;
+	constructor(e) {
+		this._zod = { def: e };
+	}
+	parse(e) {
+		let t = this.inner(e);
+		for (let e of this._zod.def.checks ?? []) {
+			let n = e.evaluate(t);
+			if (n !== !0) throw new h(n);
+		}
+		return t;
+	}
+	safeParse(e) {
+		try {
+			return {
+				success: !0,
+				data: this.parse(e)
+			};
+		} catch (e) {
+			return {
+				success: !1,
+				error: e
+			};
+		}
+	}
+	check(...e) {
+		let t = Object.create(Object.getPrototypeOf(this));
+		t._zod = { def: {
+			...this._zod.def,
+			checks: [...this._zod.def.checks ?? [], ...e]
+		} };
+		let n = m.get(this);
+		return n && m.add(t, n), t;
+	}
+	register(e, t) {
+		return e.add(this, t), this;
+	}
+}, _ = (e) => {
+	throw new h(`expected ${e}`);
+}, v = class extends g {
+	inner(e) {
+		return typeof e == "number" && !Number.isNaN(e) ? e : _("number");
+	}
+}, y = class extends g {
+	inner(e) {
+		return typeof e == "string" ? e : _("string");
+	}
+}, b = class extends g {
+	inner(e) {
+		return typeof e == "boolean" ? e : _("boolean");
+	}
+}, x = class extends g {
+	inner(e) {
+		return typeof e == "bigint" ? e : _("bigint");
+	}
+}, S = class extends g {
+	inner(e) {
+		return e;
+	}
+}, C = class extends g {
+	inner(e) {
+		let t = this._zod.def.cls;
+		return e instanceof t ? e : _(t.name ?? "instance");
+	}
+}, w = class extends g {
+	get shape() {
+		return this._zod.def.shape;
+	}
+	inner(e) {
+		(typeof e != "object" || !e || Array.isArray(e)) && _("object");
+		let t = {};
+		for (let [n, r] of Object.entries(this.shape)) t[n] = r.parse(e[n]);
+		return t;
+	}
+}, T = class extends g {
+	inner(e) {
+		if (!Array.isArray(e)) return _("array");
+		let t = this._zod.def.element;
+		return e.map((e) => t.parse(e));
+	}
+}, E = () => new v({ type: "number" }), D = () => new y({ type: "string" }), O = () => new b({ type: "boolean" }), k = () => new x({ type: "bigint" }), A = () => new S({ type: "unknown" }), j = (e) => new C({
+	type: "instanceof",
+	cls: e
+}), M = (e) => new w({
+	type: "object",
+	shape: e
+}), N = (e) => new T({
+	type: "array",
+	element: e
+}), P = () => new v({
+	type: "number",
+	format: "int32"
+}).check(d("int32", t, n)), F = () => new v({
+	type: "number",
+	format: "uint32"
+}).check(d("uint32", 0, 4294967295)), I = () => new v({
+	type: "number",
+	format: "float32"
+}), L = () => new v({
+	type: "number",
+	format: "float64"
+}), R = () => new x({
+	type: "bigint",
+	format: "int64"
+}).check(f("int64", -(2n ** 63n), 2n ** 63n - 1n)), z = () => new x({
+	type: "bigint",
+	format: "uint64"
+}).check(f("uint64", 0n, 2n ** 64n - 1n)), B = /* @__PURE__ */ new Set([
+	"string",
+	"array",
+	"set"
+]), V = (e, t, n) => {
+	let r = B.has(e._zod.def.type);
+	return t === "min" ? r ? u(n) : i(n) : r ? l(n) : a(n);
+};
+function H(e) {
+	let t = e.check.bind(e), n = e.register.bind(e), i = {
+		refine: (e, n) => H(t(s(e, n))),
+		meta: (t) => t === void 0 ? m.get(e) : H(n(m, t)),
+		min: (n) => H(t(V(e, "min", n))),
+		max: (n) => H(t(V(e, "max", n))),
+		length: (e) => H(t(c(e))),
+		int: () => H(t(r()))
+	};
+	for (let [t, n] of Object.entries(i)) Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !1,
+		configurable: !0
+	});
+	return e;
+}
+var U = {
+	number: E,
+	string: D,
+	boolean: O,
+	bigint: k,
+	object: M,
+	array: N,
+	instanceof: j,
+	unknown: A,
+	int32: P,
+	uint32: F,
+	float32: I,
+	float64: L,
+	int64: R,
+	uint64: z,
+	int: r,
+	gte: i,
+	lte: a,
+	nonnegative: o,
+	refine: s,
+	length: c,
+	maxLength: l,
+	minLength: u,
+	globalRegistry: m,
+	ZodType: g,
+	ZodObject: w,
+	ZodArray: T,
+	ZodString: y
 };
 //#endregion
-export { v as z };
+export { h as SchemaError, g as ZodType, H as fluent, m as globalRegistry, U as z };
 
 //# sourceMappingURL=index3.js.map

package/dist/index4.js

@@ -1,38 +1,43 @@
-import { z as e } from "./index3.js";
+import { fluent as e, z as t } from "./index3.js";
 //#region src/contract/listSchema.ts
-var t = new TextEncoder(), n = {
-	i8: e.number().int().min(-128).max(127),
-	u8: e.number().int().min(0).max(255),
-	i16: e.number().int().min(-32768).max(32767),
-	u16: e.number().int().min(0).max(65535),
-	i32: e.number().int().min(-2147483648).max(2147483647),
-	u32: e.number().int().min(0).max(4294967295),
-	f32: e.number(),
-	f64: e.number(),
-	i64: e.bigint(),
-	u64: e.bigint().nonnegative()
-}, r = (n) => e.string().refine((e) => t.encode(e).byteLength <= n, `exceeds ${n} UTF-8 bytes`);
-function i(t) {
-	let n = {};
-	for (let e of Object.keys(t)) n[e] = a(t[e]);
-	return e.object(n);
+var n = new TextEncoder(), r = (n, r) => e(t.number().check(t.int(), t.gte(n), t.lte(r))), i = {
+	i8: r(-128, 127),
+	u8: r(0, 255),
+	i16: r(-32768, 32767),
+	u16: r(0, 65535),
+	i32: e(t.int32()),
+	u32: e(t.uint32()),
+	f32: e(t.number()),
+	f64: e(t.number()),
+	i64: e(t.bigint()),
+	u64: e(t.bigint().check(t.nonnegative()))
+}, a = (r) => e(t.string().check(t.refine((e) => n.encode(e).byteLength <= r, `exceeds ${r} UTF-8 bytes`)));
+function o(n) {
+	let r = {};
+	for (let e of Object.keys(n)) r[e] = c(n[e]);
+	return e(t.object(r));
 }
-function a(i) {
-	if (i instanceof e.ZodType) {
-		let e = i._zod.def?.type === "string" ? m(i) : void 0;
-		return typeof e == "number" ? i.refine((n) => t.encode(n).byteLength <= e, `exceeds ${e} UTF-8 bytes`) : i;
+function s(e) {
+	return typeof e == "object" && !!e && typeof e._zod?.def == "object";
+}
+function c(e) {
+	if (s(e)) {
+		let r = e._zod.def?.type === "string" ? _(e) : void 0;
+		if (typeof r != "number") return e;
+		let i = (e) => n.encode(e).byteLength <= r, a = `exceeds ${r} UTF-8 bytes`;
+		return typeof e.refine == "function" ? e.refine(i, a) : e.check(t.refine(i, a));
 	}
-	return typeof i == "string" ? n[i] : "string" in i ? r(i.string) : e.boolean();
+	return typeof e == "string" ? i[e] : "string" in e ? a(e.string) : t.boolean();
 }
-var o = {
+var l = {
 	int32: "i32",
 	uint32: "u32",
 	float32: "f32",
 	float64: "f64"
-}, s = {
+}, u = {
 	int64: "i64",
 	uint64: "u64"
-}, c = [
+}, d = [
 	{
 		kind: "u8",
 		min: 0,
@@ -63,60 +68,60 @@ var o = {
 		min: -2147483648,
 		max: 2147483647
 	}
-], l = (e) => e.def ?? e._zod?.def;
-function u(e) {
-	let t = [e.format, ...(e.checks ?? []).map((e) => l(e)?.format)], n = t.find((e) => !!e && e in o);
-	if (n) return o[n];
+], f = (e) => e.def ?? e._zod?.def;
+function p(e) {
+	let t = [e.format, ...(e.checks ?? []).map((e) => f(e)?.format)], n = t.find((e) => !!e && e in l);
+	if (n) return l[n];
 	if (t.includes("safeint")) {
 		let t = -Infinity, n = Infinity;
 		for (let r of e.checks ?? []) {
-			let e = l(r);
+			let e = f(r);
 			e?.check === "greater_than" && e.inclusive && (t = e.value ?? t), e?.check === "less_than" && e.inclusive && (n = e.value ?? n);
 		}
-		for (let e of c) if (t >= e.min && n <= e.max) return e.kind;
+		for (let e of d) if (t >= e.min && n <= e.max) return e.kind;
 	}
 	return "f64";
 }
-function d(t, n) {
-	if (typeof t == "string") return t;
-	if (!(t instanceof e.ZodType)) {
-		if (typeof t.string == "number" || t.bool === !0) return t;
-		throw TypeError(`member "${n}": expected a scalar token, { string: n }, { bool: true }, or a zod schema`);
+function m(e, t) {
+	if (typeof e == "string") return e;
+	if (!s(e)) {
+		if (typeof e.string == "number" || e.bool === !0) return e;
+		throw TypeError(`member "${t}": expected a scalar token, { string: n }, { bool: true }, or a zod schema`);
 	}
-	let r = t._zod.def;
-	if (r.type === "number") return u(r);
-	if (r.type === "bigint") return s[r.format ?? ""] ?? "i64";
-	if (r.type === "boolean") return { bool: !0 };
-	if (r.type === "string") {
-		let e = m(t);
-		if (typeof e == "number") return { string: e };
-		throw TypeError(`member "${n}": z.string() needs .meta({ bytes: n }) — inline strings are fixed-width`);
+	let n = e._zod.def;
+	if (n.type === "number") return p(n);
+	if (n.type === "bigint") return u[n.format ?? ""] ?? "i64";
+	if (n.type === "boolean") return { bool: !0 };
+	if (n.type === "string") {
+		let n = _(e);
+		if (typeof n == "number") return { string: n };
+		throw TypeError(`member "${t}": z.string() needs .meta({ bytes: n }) — inline strings are fixed-width`);
 	}
-	throw TypeError(`member "${n}": zod "${r.type}" can't lay out as a fixed-width scalar — use number, bigint, boolean, or a bounded string`);
+	throw TypeError(`member "${t}": zod "${n.type}" can't lay out as a fixed-width scalar — use number, bigint, boolean, or a bounded string`);
 }
-function f(t) {
-	return t instanceof e.ZodObject ? t._zod.def.shape : null;
+function h(e) {
+	return !s(e) || e._zod.def.type !== "object" ? null : e._zod.def.shape;
 }
-function p(t) {
-	if (!(t instanceof e.ZodArray)) return null;
-	let n = t._zod.def, r = null;
-	for (let e of n.checks ?? []) {
-		let t = l(e);
-		t?.check === "max_length" && typeof t.maximum == "number" && (r = t.maximum), t?.check === "length_equals" && typeof t.length == "number" && (r = t.length);
+function g(e) {
+	if (!s(e) || e._zod.def.type !== "array") return null;
+	let t = e._zod.def, n = null;
+	for (let e of t.checks ?? []) {
+		let t = f(e);
+		t?.check === "max_length" && typeof t.maximum == "number" && (n = t.maximum), t?.check === "length_equals" && typeof t.length == "number" && (n = t.length);
 	}
 	return {
-		element: n.element,
-		capacity: r
+		element: t.element,
+		capacity: n
 	};
 }
-function m(e) {
-	let t = e.meta?.();
-	return typeof t?.bytes == "number" ? t.bytes : null;
+function _(e) {
+	let n = t.globalRegistry.get(e) ?? e.meta?.();
+	return typeof n?.bytes == "number" ? n.bytes : null;
 }
-function h(t) {
-	return t instanceof e.ZodString ? m(t) : null;
+function v(e) {
+	return !s(e) || e._zod.def.type !== "string" ? null : _(e);
 }
 //#endregion
-export { i as listSchema, d as memberToSpec, p as zodArrayInfo, f as zodObjectShape, h as zodStringBytes };
+export { o as listSchema, m as memberToSpec, g as zodArrayInfo, h as zodObjectShape, v as zodStringBytes };
 
 //# sourceMappingURL=index4.js.map