@xmachines/play-solid 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/node_modules/@json-render/solid/dist/index.js

@@ -0,0 +1,617 @@
+import { createStateStore as e, flattenToPointers as t, getByPath as n } from "../../core/dist/chunk-AFLK3Q4T.js";
+import { evaluateVisibility as r, executeAction as i, resolveAction as a, resolveActionParam as o, resolveBindings as s, resolveElementProps as c } from "../../core/dist/index.js";
+import "./chunk-XTSB6FIM.js";
+import "../../core/dist/store-utils.js";
+import { createComponent as l, delegateEvents as u } from "solid-js/web";
+import { ErrorBoundary as d, For as f, Show as p, createContext as m, createEffect as h, createMemo as g, createSignal as _, onCleanup as v, useContext as y } from "solid-js";
+//#region ../../node_modules/@json-render/solid/dist/index.mjs
+var b = m(null);
+function x(e, n) {
+	return e ? null : Object.keys(n).length === 0 ? {} : t(n);
+}
+function S(r) {
+	let i;
+	r.store || (i = e(r.initialState ?? {}));
+	let a = () => r.store ?? i, o = r.store ? "controlled" : "uncontrolled", s = !1;
+	typeof globalThis < "u" && globalThis.process?.env?.NODE_ENV !== "production" && h(() => {
+		let e = r.store ? "controlled" : "uncontrolled";
+		e !== o && !s && (s = !0, console.warn(`StateProvider: switching from ${o} to ${e} mode is not supported.`));
+	});
+	let c = r.initialState, u = x(!!r.store, r.initialState ?? {});
+	h(() => {
+		if (r.store) return;
+		let e = r.initialState ?? {};
+		if (e === c) return;
+		c = e;
+		let n = e && Object.keys(e).length > 0 ? t(e) : {}, i = u ?? {}, o = /* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(n)]), s = {};
+		for (let e of o) i[e] !== n[e] && (s[e] = e in n ? n[e] : void 0);
+		u = n, Object.keys(s).length > 0 && a().update(s);
+	});
+	let [d, f] = _(a().getSnapshot(), { equals: !1 }), p = /* @__PURE__ */ new Set(), m = (e) => (p.add(e), () => {
+		p.delete(e);
+	}), g = (e) => {
+		for (let t of p) t(e);
+	};
+	h(() => {
+		let e = a();
+		f(e.getSnapshot()), v(e.subscribe(() => {
+			f(e.getSnapshot());
+		}));
+	});
+	let y = {
+		get state() {
+			return d();
+		},
+		get: (e) => a().get(e),
+		set: (e, t) => {
+			let i = a(), o = i.getSnapshot(), s = n(o, e);
+			if (i.set(e, t), s !== t) {
+				let n = [{
+					path: e,
+					value: t
+				}];
+				g(n), !r.store && i.getSnapshot() !== o && r.onStateChange?.(n);
+			}
+		},
+		update: (e) => {
+			let t = a(), i = t.getSnapshot();
+			t.update(e);
+			let o = [];
+			for (let [t, r] of Object.entries(e)) n(i, t) !== r && o.push({
+				path: t,
+				value: r
+			});
+			o.length > 0 && (g(o), !r.store && t.getSnapshot() !== i && r.onStateChange?.(o));
+		},
+		getSnapshot: () => a().getSnapshot(),
+		subscribeChanges: m
+	};
+	return l(b.Provider, {
+		value: y,
+		get children() {
+			return r.children;
+		}
+	});
+}
+function C() {
+	let e = y(b);
+	if (!e) throw Error("useStateStore must be used within a StateProvider");
+	return e;
+}
+function w(e) {
+	let t = C();
+	return [g(() => n(t.state, e)), (n) => t.set(e, n)];
+}
+var T = m(null);
+function E(e) {
+	let t = C(), n = { get stateModel() {
+		return t.state;
+	} }, i = {
+		isVisible: (e) => r(e, n),
+		ctx: n
+	};
+	return l(T.Provider, {
+		value: i,
+		get children() {
+			return e.children;
+		}
+	});
+}
+function D() {
+	let e = y(T);
+	if (!e) throw Error("useVisibility must be used within a VisibilityProvider");
+	return e;
+}
+var O = m(null);
+function k() {
+	return y(O);
+}
+var A = 0;
+function j() {
+	return A += 1, `${Date.now()}-${A}`;
+}
+function M(e, t) {
+	if (e == null) return e;
+	if (e === "$id") return j();
+	if (typeof e == "object" && !Array.isArray(e)) {
+		let n = e, r = Object.keys(n);
+		if (r.length === 1 && typeof n.$state == "string") return t(n.$state);
+		if (r.length === 1 && "$id" in n) return j();
+	}
+	if (Array.isArray(e)) return e.map((e) => M(e, t));
+	if (typeof e == "object") {
+		let n = {};
+		for (let [r, i] of Object.entries(e)) n[r] = M(i, t);
+		return n;
+	}
+	return e;
+}
+var N = m(null);
+function P(e) {
+	let { get: t, set: n, getSnapshot: r } = C(), o = k(), [s, c] = _(e.handlers ?? {}), [u, d] = _(/* @__PURE__ */ new Set()), [f, p] = _(null), m = (e, t) => {
+		c((n) => ({
+			...n,
+			[e]: t
+		}));
+	}, h = async (c) => {
+		let l = a(c, r());
+		if (l.action === "setState" && l.params) {
+			let e = l.params.statePath, t = l.params.value;
+			e && n(e, t);
+			return;
+		}
+		if (l.action === "pushState" && l.params) {
+			let e = l.params.statePath, r = l.params.value;
+			if (e) {
+				let i = M(r, t);
+				n(e, [...t(e) ?? [], i]);
+				let a = l.params.clearStatePath;
+				a && n(a, "");
+			}
+			return;
+		}
+		if (l.action === "removeState" && l.params) {
+			let e = l.params.statePath, r = l.params.index;
+			e !== void 0 && r !== void 0 && n(e, (t(e) ?? []).filter((e, t) => t !== r));
+			return;
+		}
+		if (l.action === "push" && l.params) {
+			let e = l.params.screen;
+			if (e) {
+				let r = t("/currentScreen"), i = t("/navStack") ?? [];
+				r ? n("/navStack", [...i, r]) : n("/navStack", [...i, ""]), n("/currentScreen", e);
+			}
+			return;
+		}
+		if (l.action === "pop") {
+			let e = t("/navStack") ?? [];
+			if (e.length > 0) {
+				let t = e[e.length - 1];
+				n("/navStack", e.slice(0, -1)), t ? n("/currentScreen", t) : n("/currentScreen", void 0);
+			}
+			return;
+		}
+		if (l.action === "validateForm") {
+			let e = o?.validateAll;
+			if (!e) {
+				console.warn("validateForm action was dispatched but no ValidationProvider is connected. Ensure ValidationProvider is rendered inside the provider tree.");
+				return;
+			}
+			let t = e(), r = {};
+			for (let [e, t] of Object.entries(o.fieldStates)) t.result && !t.result.valid && (r[e] = t.result.errors);
+			n(l.params?.statePath || "/formValidation", {
+				valid: t,
+				errors: r
+			});
+			return;
+		}
+		let u = s()[l.action];
+		if (!u) {
+			console.warn(`No handler registered for action: ${l.action}`);
+			return;
+		}
+		if (l.confirm) return new Promise((e, t) => {
+			p({
+				action: l,
+				handler: u,
+				resolve: () => {
+					p(null), e();
+				},
+				reject: () => {
+					p(null), t(/* @__PURE__ */ Error("Action cancelled"));
+				}
+			});
+		}).then(async () => {
+			d((e) => new Set(e).add(l.action));
+			try {
+				await i({
+					action: l,
+					handler: u,
+					setState: n,
+					navigate: e.navigate,
+					executeAction: async (e) => {
+						await h({ action: e });
+					}
+				});
+			} finally {
+				d((e) => {
+					let t = new Set(e);
+					return t.delete(l.action), t;
+				});
+			}
+		});
+		d((e) => new Set(e).add(l.action));
+		try {
+			await i({
+				action: l,
+				handler: u,
+				setState: n,
+				navigate: e.navigate,
+				executeAction: async (e) => {
+					await h({ action: e });
+				}
+			});
+		} finally {
+			d((e) => {
+				let t = new Set(e);
+				return t.delete(l.action), t;
+			});
+		}
+	}, g = {
+		get handlers() {
+			return s();
+		},
+		get loadingActions() {
+			return u();
+		},
+		get pendingConfirmation() {
+			return f();
+		},
+		execute: h,
+		confirm: () => {
+			f()?.resolve();
+		},
+		cancel: () => {
+			f()?.reject();
+		},
+		registerHandler: m
+	};
+	return l(N.Provider, {
+		value: g,
+		get children() {
+			return e.children;
+		}
+	});
+}
+function F() {
+	let e = y(N);
+	if (!e) throw Error("useActions must be used within an ActionProvider");
+	return e;
+}
+u(["click"]);
+var I = m(null);
+function L(e) {
+	return l(I.Provider, {
+		get value() {
+			return {
+				item: e.item,
+				index: e.index,
+				basePath: e.basePath
+			};
+		},
+		get children() {
+			return e.children;
+		}
+	});
+}
+function R() {
+	return y(I);
+}
+var z = {}, B = m(z);
+function V() {
+	return y(B) ?? z;
+}
+function H(e) {
+	let t = R(), { ctx: n } = D(), { execute: i } = F(), a = C(), u = () => a.getSnapshot(), f = V(), m = g(() => {
+		let e = t?.item, r = t?.index, i = t?.basePath;
+		return {
+			get stateModel() {
+				return n.stateModel;
+			},
+			...e === void 0 ? {} : { repeatItem: e },
+			...r === void 0 ? {} : { repeatIndex: r },
+			...i === void 0 ? {} : { repeatBasePath: i },
+			functions: f
+		};
+	}), _ = g(() => e.element.visible === void 0 ? !0 : r(e.element.visible, m())), y = async (t) => {
+		let n = e.element.on?.[t];
+		if (!n) return;
+		let r = Array.isArray(n) ? n : [n];
+		for (let e of r) {
+			if (!e.params) {
+				await i(e);
+				continue;
+			}
+			let t = {
+				...m(),
+				stateModel: u()
+			}, n = {};
+			for (let [r, i] of Object.entries(e.params)) n[r] = o(i, t);
+			await i({
+				...e,
+				params: n
+			});
+		}
+	}, b = (t) => {
+		let n = e.element.on?.[t];
+		return n ? {
+			emit: () => y(t),
+			shouldPreventDefault: (Array.isArray(n) ? n : [n]).some((e) => e.preventDefault),
+			bound: !0
+		} : {
+			emit: () => {},
+			shouldPreventDefault: !1,
+			bound: !1
+		};
+	};
+	h(() => {
+		let t = e.element.watch;
+		if (!t) return;
+		let n = Object.keys(t);
+		if (n.length === 0) return;
+		let r = a.subscribeChanges((e) => {
+			let r = new Set(e.map((e) => e.path));
+			(async () => {
+				for (let e of n) {
+					if (!r.has(e)) continue;
+					let n = t[e];
+					if (!n) continue;
+					let a = Array.isArray(n) ? n : [n];
+					for (let e of a) {
+						if (!e.params) {
+							await i(e);
+							continue;
+						}
+						let t = {
+							...m(),
+							stateModel: u()
+						}, n = {};
+						for (let [r, i] of Object.entries(e.params)) n[r] = o(i, t);
+						await i({
+							...e,
+							params: n
+						});
+					}
+				}
+			})().catch(console.error);
+		});
+		v(() => {
+			r();
+		});
+	});
+	let x = g(() => {
+		let t = e.element.props;
+		return s(t, m());
+	}), S = g(() => {
+		let t = e.element.props, n = c(t, m());
+		return n === e.element.props ? e.element : {
+			...e.element,
+			props: n
+		};
+	});
+	return l(p, {
+		get when() {
+			return _();
+		},
+		get children() {
+			return l(d, {
+				fallback: (t) => (console.error(`[json-render] Rendering error in <${e.element.type}>:`, t), null),
+				get children() {
+					return l(U, {
+						get resolvedElement() {
+							return S();
+						},
+						get spec() {
+							return e.spec;
+						},
+						get registry() {
+							return e.registry;
+						},
+						get loading() {
+							return e.loading;
+						},
+						get fallback() {
+							return e.fallback;
+						},
+						emit: y,
+						on: b,
+						get bindings() {
+							return x();
+						}
+					});
+				}
+			});
+		}
+	});
+}
+function U(e) {
+	let t = () => e.registry[e.resolvedElement.type] ?? e.fallback;
+	return l(p, {
+		get when() {
+			return t();
+		},
+		get fallback() {
+			return console.warn(`No renderer for component type: ${e.resolvedElement.type}`), null;
+		},
+		children: (t) => {
+			let n = t(), r = () => e.resolvedElement.repeat ? l(W, {
+				get element() {
+					return e.resolvedElement;
+				},
+				get spec() {
+					return e.spec;
+				},
+				get registry() {
+					return e.registry;
+				},
+				get loading() {
+					return e.loading;
+				},
+				get fallback() {
+					return e.fallback;
+				}
+			}) : l(f, {
+				get each() {
+					return e.resolvedElement.children ?? [];
+				},
+				children: (t) => {
+					let n = () => e.spec.elements[t];
+					return l(p, {
+						get when() {
+							return n();
+						},
+						get fallback() {
+							return e.loading || console.warn(`[json-render] Missing element "${t}" referenced as child of "${e.resolvedElement.type}". This element will not render.`), null;
+						},
+						children: (t) => l(H, {
+							get element() {
+								return t();
+							},
+							get spec() {
+								return e.spec;
+							},
+							get registry() {
+								return e.registry;
+							},
+							get loading() {
+								return e.loading;
+							},
+							get fallback() {
+								return e.fallback;
+							}
+						})
+					});
+				}
+			});
+			return l(n, {
+				get element() {
+					return e.resolvedElement;
+				},
+				get emit() {
+					return e.emit;
+				},
+				get on() {
+					return e.on;
+				},
+				get bindings() {
+					return e.bindings;
+				},
+				get loading() {
+					return e.loading;
+				},
+				get children() {
+					return r();
+				}
+			});
+		}
+	});
+}
+function W(e) {
+	let t = C(), r = () => e.element.repeat, i = () => r().statePath, a = () => n(t.state, i()) ?? [];
+	return l(f, {
+		get each() {
+			return a();
+		},
+		children: (t, n) => l(L, {
+			item: t,
+			get index() {
+				return n();
+			},
+			get basePath() {
+				return `${i()}/${n()}`;
+			},
+			get children() {
+				return l(f, {
+					get each() {
+						return e.element.children ?? [];
+					},
+					children: (t) => {
+						let n = () => e.spec.elements[t];
+						return l(p, {
+							get when() {
+								return n();
+							},
+							get fallback() {
+								return e.loading || console.warn(`[json-render] Missing element "${t}" referenced as child of "${e.element.type}" (repeat). This element will not render.`), null;
+							},
+							children: (t) => l(H, {
+								get element() {
+									return t();
+								},
+								get spec() {
+									return e.spec;
+								},
+								get registry() {
+									return e.registry;
+								},
+								get loading() {
+									return e.loading;
+								},
+								get fallback() {
+									return e.fallback;
+								}
+							})
+						});
+					}
+				});
+			}
+		})
+	});
+}
+function G(e) {
+	let t = g(() => {
+		let t = e.spec;
+		if (!(!t || !t.root)) return t.elements[t.root];
+	});
+	return l(p, {
+		get when() {
+			return t();
+		},
+		children: (t) => l(H, {
+			get element() {
+				return t();
+			},
+			get spec() {
+				return e.spec;
+			},
+			get registry() {
+				return e.registry;
+			},
+			get loading() {
+				return e.loading;
+			},
+			get fallback() {
+				return e.fallback;
+			}
+		})
+	});
+}
+function K(e, t) {
+	let n = {};
+	if (t.components) for (let [e, r] of Object.entries(t.components)) n[e] = (e) => r({
+		get props() {
+			return e.element.props;
+		},
+		get children() {
+			return e.children;
+		},
+		emit: e.emit,
+		on: e.on,
+		get bindings() {
+			return e.bindings;
+		},
+		get loading() {
+			return e.loading;
+		}
+	});
+	let r = t.actions ? Object.entries(t.actions) : [];
+	return {
+		registry: n,
+		handlers: (e, t) => {
+			let n = {};
+			for (let [i, a] of r) n[i] = async (n) => {
+				let r = e(), i = t();
+				r && await a(n, r, i);
+			};
+			return n;
+		},
+		executeAction: async (e, t, n, i = {}) => {
+			let a = r.find(([t]) => t === e);
+			a ? await a[1](t, n, i) : console.warn(`Unknown action: ${e}`);
+		}
+	};
+}
+//#endregion
+export { P as ActionProvider, G as Renderer, S as StateProvider, E as VisibilityProvider, K as defineRegistry, w as useStateBinding };
+
+//# sourceMappingURL=index.js.map