@kontsedal/olas-core 0.0.1 → 0.0.2

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

@@ -212,14 +212,16 @@ function untracked(fn) {
 //#endregion
 //#region src/utils.ts
 /**
-* True iff `err` is an AbortError. Used to filter superseded latest-wins
-* mutations and aborted fetches from genuine failures.
+* True iff `err` looks like an AbortError. Matches the standard `DOMException`
+* shape thrown by `AbortController` AND any object whose `name === 'AbortError'`
+* — that covers axios / msw / user-thrown plain Errors that signal abort.
 *
-* Spec: §20.12 — checks `err instanceof DOMException && err.name === 'AbortError'`.
-* Node 17+ exposes a global DOMException, so this works server-side too.
+* Spec: §20.12. Node 17+ exposes a global DOMException, so the instanceof
+* branch works server-side; the name-based branch is the portable fallback.
 */
 function isAbortError(err) {
 	if (typeof DOMException !== "undefined" && err instanceof DOMException) return err.name === "AbortError";
+	if (err != null && typeof err === "object" && "name" in err) return err.name === "AbortError";
 	return false;
 }
 /**
@@ -1630,12 +1632,25 @@ function waitUntilFalse(sig) {
 //#endregion
 //#region src/emitter.ts
 var EmitterImpl = class {
+	onError;
 	handlers = /* @__PURE__ */ new Set();
 	disposed = false;
+	constructor(onError) {
+		this.onError = onError;
+	}
 	emit(value) {
 		if (this.disposed) return;
 		const snapshot = Array.from(this.handlers);
-		for (const handler of snapshot) handler(value);
+		for (const handler of snapshot) try {
+			handler(value);
+		} catch (err) {
+			if (this.onError) try {
+				this.onError(err);
+			} catch {
+				console.error("[olas] emitter handler threw and reporter threw:", err);
+			}
+			else console.error("[olas] emitter handler threw:", err);
+		}
 	}
 	on(handler) {
 		if (this.disposed) return () => {};
@@ -1667,9 +1682,14 @@ var EmitterImpl = class {
 * (or the emitter is disposed). Use this for emitters that live outside any
 * single controller — typically in deps. Use `ctx.emitter()` for emitters that
 * should auto-clean with a controller.
+*
+* Pass `onError` to receive emit-time handler throws (spec §20.6 — one
+* throwing handler must not block the rest of the fan-out). `ctx.emitter()`
+* wires this to the root's `onError` so deps-level emitters get isolation
+* by default when constructed via `ctx`.
 */
-function createEmitter() {
-	const impl = new EmitterImpl();
+function createEmitter(options) {
+	const impl = new EmitterImpl(options?.onError);
 	return {
 		emit: ((value) => impl.emit(value)),
 		on: (handler) => impl.on(handler),
@@ -2034,8 +2054,23 @@ var FormImpl = class {
 			else child.set(val);
 			else if (isFieldArray(child)) {
 				const arr = child;
-				arr.clear();
-				for (const itemVal of val) arr.add(itemVal);
+				const newValues = val;
+				if (asInitial) {
+					arr.clear();
+					for (const itemVal of newValues) arr.add(itemVal);
+					arr.replaceInitialItems(newValues);
+				} else {
+					const current = arr.items.peek();
+					const overlap = Math.min(current.length, newValues.length);
+					for (let i = 0; i < overlap; i++) {
+						const item = current[i];
+						const v = newValues[i];
+						if (isForm(item)) item.set(v);
+						else item.set(v);
+					}
+					for (let i = current.length; i < newValues.length; i++) arr.add(newValues[i]);
+					for (let i = current.length - 1; i >= newValues.length; i--) arr.remove(i);
+				}
 			} else {
 				const f = child;
 				if (asInitial) f.setAsInitial(val);
@@ -2283,6 +2318,15 @@ var FieldArrayImpl = class {
 		for (const item of this.items$.peek()) item.dispose?.();
 		this.items$.set([]);
 	}
+	/**
+	* Internal — used by `Form.resetWithInitial` to re-anchor the array's
+	* initial items after a parent-driven `applyPartial(..., asInitial: true)`.
+	* Without this, a subsequent `reset()` would revert to the construction-
+	* time initials rather than the most-recently-applied ones.
+	*/
+	replaceInitialItems(items) {
+		this.initialItems = [...items];
+	}
 	reset() {
 		if (this.disposed) return;
 		batch(() => {
@@ -3228,7 +3272,12 @@ var ControllerInstance = class ControllerInstance {
 				return m;
 			},
 			emitter() {
-				const e = createEmitter();
+				const e = createEmitter({ onError: (err) => {
+					dispatchError(self.rootShared.onError, err, {
+						kind: "emitter",
+						controllerPath: self.path
+					});
+				} });
 				self.entries.push({
 					kind: "cleanup",
 					dispose: () => e.dispose()
@@ -3395,6 +3444,255 @@ var ControllerInstance = class ControllerInstance {
 					}
 				};
 			},
+			session(def, props, options) {
+				const segment = self.makeChildSegment(getFactory(def), getName(def));
+				const override = options?.deps;
+				const childDeps = override !== void 0 ? {
+					...self.deps,
+					...override
+				} : self.deps;
+				const childInstance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+				const api = childInstance.construct(getFactory(def), props);
+				const entry = {
+					kind: "child",
+					instance: childInstance
+				};
+				self.entries.push(entry);
+				let disposed = false;
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					const idx = self.entries.indexOf(entry);
+					if (idx >= 0) self.entries.splice(idx, 1);
+					try {
+						childInstance.dispose();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				return [api, dispose];
+			},
+			collection(options) {
+				const childMap = /* @__PURE__ */ new Map();
+				const items$ = signal([]);
+				const size$ = computed(() => items$.value.length);
+				const isFactoryForm = options.factory !== void 0;
+				const buildChild = (item) => {
+					let def;
+					let childProps;
+					if (isFactoryForm) {
+						const result = options.factory(item);
+						def = result.controller;
+						childProps = result.props;
+					} else {
+						const homoOpts = options;
+						def = homoOpts.controller;
+						childProps = homoOpts.propsOf(item);
+					}
+					const segment = self.makeChildSegment(getFactory(def), getName(def));
+					const childDeps = options.deps !== void 0 ? {
+						...self.deps,
+						...options.deps
+					} : self.deps;
+					const instance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+					try {
+						return {
+							instance,
+							api: instance.construct(getFactory(def), childProps),
+							def
+						};
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "construction",
+							controllerPath: self.path
+						});
+						return null;
+					}
+				};
+				const removeKey = (key) => {
+					const info = childMap.get(key);
+					if (info === void 0) return;
+					childMap.delete(key);
+					const idx = self.entries.indexOf(info.entry);
+					if (idx >= 0) self.entries.splice(idx, 1);
+					try {
+						info.instance.dispose();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				const reconcile = () => {
+					const source = options.source.value;
+					const itemByKey = /* @__PURE__ */ new Map();
+					for (const item of source) {
+						const key = options.keyOf(item);
+						if (!itemByKey.has(key)) itemByKey.set(key, item);
+					}
+					for (const key of [...childMap.keys()]) if (!itemByKey.has(key)) removeKey(key);
+					for (const [key, item] of itemByKey) {
+						const existing = childMap.get(key);
+						if (existing !== void 0) {
+							if (isFactoryForm) {
+								if (options.factory(item).controller !== existing.def) {
+									removeKey(key);
+									const built = buildChild(item);
+									if (built !== null) {
+										const entry = {
+											kind: "child",
+											instance: built.instance
+										};
+										self.entries.push(entry);
+										childMap.set(key, {
+											...built,
+											entry
+										});
+									}
+								}
+							}
+							continue;
+						}
+						const built = buildChild(item);
+						if (built !== null) {
+							const entry = {
+								kind: "child",
+								instance: built.instance
+							};
+							self.entries.push(entry);
+							childMap.set(key, {
+								...built,
+								entry
+							});
+						}
+					}
+					const next = [];
+					const seen = /* @__PURE__ */ new Set();
+					for (const item of source) {
+						const key = options.keyOf(item);
+						if (seen.has(key)) continue;
+						seen.add(key);
+						const info = childMap.get(key);
+						if (info !== void 0) next.push({
+							key,
+							api: info.api
+						});
+					}
+					items$.set(next);
+				};
+				const wrapped = () => {
+					try {
+						reconcile();
+					} catch (err) {
+						dispatchError(self.rootShared.onError, err, {
+							kind: "effect",
+							controllerPath: self.path
+						});
+					}
+				};
+				const effectEntry = {
+					kind: "effect",
+					factory: wrapped,
+					dispose: null
+				};
+				if (self.state !== "suspended") effectEntry.dispose = effect(wrapped);
+				self.entries.push(effectEntry);
+				return {
+					items: items$,
+					size: size$,
+					get: (key) => childMap.get(key)?.api,
+					has: (key) => childMap.has(key)
+				};
+			},
+			lazyChild(loader, props, options) {
+				const status$ = signal("idle");
+				const api$ = signal(void 0);
+				const error$ = signal(void 0);
+				let childInstance = null;
+				let childEntry = null;
+				let pendingLoad = null;
+				let disposed = false;
+				const flagEntry = {
+					kind: "onDispose",
+					fn: () => {
+						disposed = true;
+					}
+				};
+				self.entries.push(flagEntry);
+				const handleFailure = (err) => {
+					status$.set("error");
+					error$.set(err);
+					dispatchError(self.rootShared.onError, err, {
+						kind: "construction",
+						controllerPath: self.path
+					});
+				};
+				const load = () => {
+					if (disposed) return Promise.reject(/* @__PURE__ */ new Error("[olas] ctx.lazyChild: cannot load after dispose"));
+					if (pendingLoad !== null) return pendingLoad;
+					status$.set("loading");
+					pendingLoad = loader().then((def) => {
+						if (disposed) throw new Error("[olas] ctx.lazyChild: disposed during load");
+						const segment = self.makeChildSegment(getFactory(def), getName(def));
+						const childDeps = options?.deps !== void 0 ? {
+							...self.deps,
+							...options.deps
+						} : self.deps;
+						const instance = new ControllerInstance(self, self.rootShared, segment, childDeps);
+						try {
+							const api = instance.construct(getFactory(def), props);
+							childInstance = instance;
+							childEntry = {
+								kind: "child",
+								instance
+							};
+							self.entries.push(childEntry);
+							api$.set(api);
+							status$.set("ready");
+							return api;
+						} catch (err) {
+							handleFailure(err);
+							throw err;
+						}
+					}, (err) => {
+						if (disposed) throw err;
+						handleFailure(err);
+						throw err;
+					});
+					return pendingLoad;
+				};
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					if (childEntry !== null && childInstance !== null) {
+						const idx = self.entries.indexOf(childEntry);
+						if (idx >= 0) self.entries.splice(idx, 1);
+						try {
+							childInstance.dispose();
+						} catch (err) {
+							dispatchError(self.rootShared.onError, err, {
+								kind: "effect",
+								controllerPath: self.path
+							});
+						}
+						childInstance = null;
+						childEntry = null;
+					}
+					const flagIdx = self.entries.indexOf(flagEntry);
+					if (flagIdx >= 0) self.entries.splice(flagIdx, 1);
+				};
+				return {
+					status: status$,
+					api: api$,
+					error: error$,
+					load,
+					dispose
+				};
+			},
 			onDispose(fn) {
 				self.entries.push({
 					kind: "onDispose",
@@ -3653,4 +3951,4 @@ Object.defineProperty(exports, "untracked", {
 	}
 });
 
-//# sourceMappingURL=root-DXV1gVbQ.cjs.map
+//# sourceMappingURL=root-XKEsSmcd.cjs.map