@kontsedal/olas-core 0.0.2 → 0.0.3

package/dist/{root-XKEsSmcd.cjs → root-D_xAdcom.cjs}

@@ -248,6 +248,83 @@ function abortableSleep(ms, signal) {
 	});
 }
 //#endregion
+//#region src/query/structural-share.ts
+/**
+* Walk `prev` and `next` in parallel. Wherever a sub-tree in `next` is
+* structurally equal to the corresponding sub-tree in `prev`, return `prev`'s
+* reference for that sub-tree. Otherwise return `next`'s.
+*
+* Result: a value that is `===` to `prev` on every refetch where the payload
+* didn't actually change, and shares maximum ref-identity on partial changes.
+* Downstream `computed`s and React `useSyncExternalStore` snapshots stop
+* thrashing because reference equality holds where content equality holds.
+*
+* Bails (returns the `next` ref unchanged, no recursion) on:
+*   - Mismatched constructors / different `typeof` between `prev` and `next`
+*   - `Map`, `Set`, `Date`, `RegExp`, class instances (anything where the
+*     plain-object / array fast path isn't safe)
+*   - Functions, symbols, promises
+*
+* Handles cycles via a `WeakSet` of in-progress objects — a self-referential
+* payload that compares structurally identical against itself won't loop.
+*/
+function structuralShare(prev, next) {
+	if (Object.is(prev, next)) return prev;
+	return walk(prev, next, /* @__PURE__ */ new WeakSet());
+}
+function walk(prev, next, seen) {
+	if (Object.is(prev, next)) return prev;
+	if (prev === null || next === null) return next;
+	if (typeof prev !== "object" || typeof next !== "object") return next;
+	if (seen.has(prev) || seen.has(next)) return next;
+	if (Array.isArray(prev) && Array.isArray(next)) return walkArray(prev, next, seen);
+	if (Array.isArray(prev) !== Array.isArray(next)) return next;
+	const prevProto = Object.getPrototypeOf(prev);
+	if (prevProto !== Object.getPrototypeOf(next)) return next;
+	if (prevProto !== Object.prototype && prevProto !== null) return next;
+	return walkPlainObject(prev, next, seen);
+}
+function walkArray(prev, next, seen) {
+	if (prev.length !== next.length) {}
+	seen.add(prev);
+	seen.add(next);
+	try {
+		const out = new Array(next.length);
+		let changed = next.length !== prev.length;
+		for (let i = 0; i < next.length; i++) {
+			const shared = walk(i < prev.length ? prev[i] : void 0, next[i], seen);
+			out[i] = shared;
+			if (shared !== prev[i]) changed = true;
+		}
+		if (!changed) return prev;
+		return out;
+	} finally {
+		seen.delete(prev);
+		seen.delete(next);
+	}
+}
+function walkPlainObject(prev, next, seen) {
+	const prevKeys = Object.keys(prev);
+	const nextKeys = Object.keys(next);
+	let changed = prevKeys.length !== nextKeys.length;
+	seen.add(prev);
+	seen.add(next);
+	try {
+		const out = {};
+		for (const key of nextKeys) {
+			const shared = walk(prev[key], next[key], seen);
+			out[key] = shared;
+			if (shared !== prev[key]) changed = true;
+			else if (!(key in prev)) changed = true;
+		}
+		if (!changed) return prev;
+		return out;
+	} finally {
+		seen.delete(prev);
+		seen.delete(next);
+	}
+}
+//#endregion
 //#region src/query/entry.ts
 /**
 * One cache entry's state machine. Owns the AsyncState signals, race
@@ -354,8 +431,10 @@ var Entry = class {
 		return typeof d === "function" ? d(attempt) : d;
 	}
 	applySuccess(result) {
+		const prev = this.data.peek();
+		const shared = prev === void 0 ? result : structuralShare(prev, result);
 		batch(() => {
-			this.data.set(result);
+			this.data.set(shared);
 			this.error.set(void 0);
 			this.status.set("success");
 			this.isLoading.set(false);
@@ -367,8 +446,8 @@ var Entry = class {
 		try {
 			this.events.onFetchSuccess?.(Date.now() - this.fetchStartTime);
 		} catch {}
-		this.onSuccessData?.(result);
-		return result;
+		this.onSuccessData?.(shared);
+		return shared;
 	}
 	applyFailure(err) {
 		batch(() => {
@@ -636,8 +715,10 @@ var InfiniteEntry = class {
 		});
 		return this.runFetch(myId, abort.signal, this.initialPageParam, (page, param) => {
 			if (myId !== this.currentFetchId || this.disposed) return;
+			const prevPages = this.pages.peek();
+			const sharedPage = prevPages.length > 0 ? structuralShare(prevPages[0], page) : page;
 			batch(() => {
-				this.pages.set([page]);
+				this.pages.set([sharedPage]);
 				this.pageParams.set([param]);
 				this.error.set(void 0);
 				this.status.set("success");
@@ -1701,6 +1782,17 @@ function createEmitter(options) {
 //#region src/forms/field.ts
 var FieldImpl = class {
 	value$;
+	/**
+	* Validator-produced errors. The public `errors` getter merges this with
+	* `serverErrors$` so consumers see a single flat array. Kept separate so a
+	* re-run of validators (after a new value) doesn't clobber server errors.
+	*/
+	validatorErrors$;
+	/**
+	* Externally-injected errors — see `setErrors`. Cleared on the next user
+	* `set()`, on `reset()`, or via an explicit `setErrors([])`.
+	*/
+	serverErrors$;
 	errors$;
 	touched$;
 	dirty$;
@@ -1722,11 +1814,19 @@ var FieldImpl = class {
 		this.validators = validators;
 		this.onValidatorError = options?.onValidatorError ?? null;
 		this.value$ = signal(initial);
-		this.errors$ = signal([]);
+		this.validatorErrors$ = signal([]);
+		this.serverErrors$ = signal([]);
 		this.touched$ = signal(false);
 		this.dirty$ = signal(false);
 		this.validating$ = signal(false);
 		this.revalidateTrigger$ = signal(0);
+		this.errors$ = computed(() => {
+			const v = this.validatorErrors$.value;
+			const s = this.serverErrors$.value;
+			if (s.length === 0) return v;
+			if (v.length === 0) return s;
+			return [...v, ...s];
+		});
 		this.isValid$ = computed(() => this.errors$.value.length === 0 && !this.validating$.value);
 		if (validators.length > 0) this.validatorDispose = effect(() => {
 			this.runValidators();
@@ -1765,8 +1865,16 @@ var FieldImpl = class {
 	}
 	set(value) {
 		if (this.disposed) return;
-		this.value$.set(value);
-		this.dirty$.set(true);
+		batch(() => {
+			this.value$.set(value);
+			this.dirty$.set(true);
+			if (this.serverErrors$.peek().length > 0) this.serverErrors$.set([]);
+		});
+	}
+	setErrors(errors) {
+		if (this.disposed) return;
+		const next = errors.length === 0 ? [] : [...errors];
+		this.serverErrors$.set(next);
 	}
 	/**
 	* Reseat the field as if this value had been its constructor `initial`.
@@ -1791,7 +1899,8 @@ var FieldImpl = class {
 			this.value$.set(this.initial);
 			this.dirty$.set(false);
 			this.touched$.set(false);
-			this.errors$.set([]);
+			this.validatorErrors$.set([]);
+			this.serverErrors$.set([]);
 			this.validating$.set(false);
 		});
 	}
@@ -1857,7 +1966,7 @@ var FieldImpl = class {
 		}
 		if (syncErrors.length > 0) {
 			batch(() => {
-				this.errors$.set(syncErrors);
+				this.validatorErrors$.set(syncErrors);
 				this.validating$.set(false);
 			});
 			this.emitValidated(false, syncErrors);
@@ -1865,14 +1974,14 @@ var FieldImpl = class {
 		}
 		if (asyncPromises.length === 0) {
 			batch(() => {
-				this.errors$.set([]);
+				this.validatorErrors$.set([]);
 				this.validating$.set(false);
 			});
 			this.emitValidated(true, []);
 			return;
 		}
 		batch(() => {
-			this.errors$.set([]);
+			this.validatorErrors$.set([]);
 			this.validating$.set(true);
 		});
 		Promise.allSettled(asyncPromises).then((results) => {
@@ -1885,7 +1994,7 @@ var FieldImpl = class {
 				asyncErrors.push(msg);
 			}
 			batch(() => {
-				this.errors$.set(asyncErrors);
+				this.validatorErrors$.set(asyncErrors);
 				this.validating$.set(false);
 			});
 			this.emitValidated(asyncErrors.length === 0, asyncErrors);
@@ -1956,6 +2065,12 @@ var FormImpl = class {
 	topLevelErrors$ = signal([]);
 	topLevelErrors = this.topLevelErrors$;
 	topLevelValidating$ = signal(false);
+	isSubmitting$ = signal(false);
+	submitCount$ = signal(0);
+	submitError$ = signal(void 0);
+	isSubmitting = this.isSubmitting$;
+	submitCount = this.submitCount$;
+	submitError = this.submitError$;
 	validators;
 	options;
 	validatorDispose = null;
@@ -2118,6 +2233,107 @@ var FormImpl = class {
 		});
 		return this.isValid.peek();
 	}
+	/**
+	* Run a submission against this form. Wraps `handler(value)` with:
+	* - `isSubmitting` set true while the handler is in flight.
+	* - `submitCount` incremented before the handler runs.
+	* - `submitError` set to the throw, if any.
+	* - Optional pre-submit `validate()` (default true). When invalid every
+	*   field is marked touched and the handler is skipped — the returned
+	*   promise resolves with `{ ok: false }` and `submitError` is left
+	*   untouched (validation failure is not a thrown error).
+	*
+	* The handler may return a value (synchronously or via Promise); it's
+	* captured in the resolved object's `data` field. Throws are captured
+	* unless `onError: 'rethrow'`. A `resetOnSuccess: true` option calls
+	* `reset()` after the handler resolves successfully.
+	*/
+	async submit(handler, options) {
+		if (this.disposed) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("form is disposed")
+		};
+		if (this.isSubmitting$.peek()) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("submit already in progress")
+		};
+		const validateFirst = options?.validateBeforeSubmit ?? true;
+		const onErrorMode = options?.onError ?? "capture";
+		batch(() => {
+			this.submitCount$.update((n) => n + 1);
+			this.submitError$.set(void 0);
+			this.isSubmitting$.set(true);
+		});
+		try {
+			if (validateFirst) {
+				if (!await this.validate()) {
+					this.markAllTouched();
+					this.isSubmitting$.set(false);
+					return { ok: false };
+				}
+			}
+			const result = await handler(this.value.peek());
+			if (options?.resetOnSuccess) this.reset();
+			this.isSubmitting$.set(false);
+			return {
+				ok: true,
+				data: result
+			};
+		} catch (err) {
+			batch(() => {
+				this.submitError$.set(err);
+				this.isSubmitting$.set(false);
+			});
+			if (onErrorMode === "rethrow") throw err;
+			return {
+				ok: false,
+				error: err
+			};
+		}
+	}
+	/**
+	* Pin externally-sourced errors on specific fields — typically server-side
+	* validation results from a failed submit. Paths are dot-separated and
+	* traverse nested `Form` / `FieldArray` children (numeric segments are
+	* array indices). Errors land in the field's `serverErrors` channel and
+	* clear automatically on the next user write to that field. Passing an
+	* empty array for a path clears that field's server errors immediately.
+	*/
+	setErrors(errors) {
+		if (this.disposed) return;
+		batch(() => {
+			for (const [path, msgs] of Object.entries(errors)) {
+				const target = this.resolvePath(path);
+				if (target === void 0) continue;
+				if (target.setErrors === void 0) continue;
+				target.setErrors(msgs);
+			}
+		});
+	}
+	resolvePath(path) {
+		if (path === "") return void 0;
+		const segments = path.split(".");
+		let cursor = this;
+		for (const seg of segments) {
+			if (cursor === void 0 || cursor === null) return void 0;
+			if (isForm(cursor)) {
+				cursor = cursor.fields[seg];
+				continue;
+			}
+			if (isFieldArray(cursor)) {
+				const idx = Number(seg);
+				if (!Number.isInteger(idx) || idx < 0) return void 0;
+				cursor = cursor.at(idx);
+				continue;
+			}
+			if (cursor === this) {
+				cursor = this.fields[seg];
+				continue;
+			}
+			return;
+		}
+		return cursor;
+	}
 	dispose() {
 		if (this.disposed) return;
 		this.disposed = true;
@@ -2779,6 +2995,7 @@ function raceAbort(promise, signal) {
 //#region src/query/use.ts
 var SubscriptionImpl = class {
 	keepPreviousData;
+	select;
 	current$ = signal(null);
 	previousData$ = signal(void 0);
 	data;
@@ -2789,13 +3006,18 @@ var SubscriptionImpl = class {
 	isStale;
 	lastUpdatedAt;
 	hasPendingMutations;
-	constructor(keepPreviousData) {
+	constructor(keepPreviousData, select) {
 		this.keepPreviousData = keepPreviousData;
-		this.data = computed(() => {
+		this.select = select;
+		const rawData = computed(() => {
 			const curData = this.current$.value?.entry.data.value;
 			if (curData !== void 0) return curData;
 			if (keepPreviousData) return this.previousData$.value;
 		});
+		this.data = select === void 0 ? rawData : computed(() => {
+			const raw = rawData.value;
+			return raw === void 0 ? void 0 : select(raw);
+		});
 		this.error = computed(() => this.current$.value?.entry.error.value);
 		this.status = computed(() => this.current$.value?.entry.status.value ?? "idle");
 		this.isLoading = computed(() => {
@@ -2824,7 +3046,7 @@ var SubscriptionImpl = class {
 	refetch = () => {
 		const cur = this.current$.peek();
 		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
-		return cur.entry.refetch();
+		return cur.entry.refetch().then((v) => this.project(v));
 	};
 	reset = () => {
 		this.current$.peek()?.entry.reset();
@@ -2832,18 +3054,26 @@ var SubscriptionImpl = class {
 	firstValue = () => {
 		const cur = this.current$.peek();
 		if (!cur) return Promise.reject(/* @__PURE__ */ new Error("[olas] no active subscription"));
-		return cur.entry.firstValue();
+		return cur.entry.firstValue().then((v) => this.project(v));
 	};
+	project(v) {
+		return this.select === void 0 ? v : this.select(v);
+	}
 };
 /**
 * Build a subscription + the effect that keeps it bound to the right entry.
 * The controller container wires the disposer into the lifecycle.
+*
+* `keyOrOptions` may carry an optional `select` projection that maps the
+* underlying `T` to a view `U`; the returned subscription's data shape
+* widens accordingly. Without `select`, `U = T` and the projection
+* computed is skipped.
 */
 function createUse(client, query, keyOrOptions) {
 	const keepPreviousData = query.__spec.keepPreviousData ?? false;
 	const keyFn = typeof keyOrOptions === "function" ? keyOrOptions : keyOrOptions?.key;
 	const enabledFn = typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.enabled : void 0;
-	const sub = new SubscriptionImpl(keepPreviousData);
+	const sub = new SubscriptionImpl(keepPreviousData, typeof keyOrOptions === "object" && keyOrOptions !== null ? keyOrOptions.select : void 0);
 	let currentEntry = null;
 	let suspended = false;
 	const effectDispose = effect(() => {
@@ -3951,4 +4181,4 @@ Object.defineProperty(exports, "untracked", {
 	}
 });
 
-//# sourceMappingURL=root-XKEsSmcd.cjs.map
+//# sourceMappingURL=root-D_xAdcom.cjs.map