likec4 1.59.4 → 1.60.0

package/__app__/codegen/react.mjs

@@ -1,10 +1,10 @@
 import "../src/chunks/rolldown-runtime.mjs";
-import { $likec4model as e, IconRenderer as t } from "likec4:single-project";
-import { LikeC4ModelProvider as n, LikeC4View as r, ReactLikeC4 as i, useLikeC4Model as a, useLikeC4View as o } from "likec4:react";
+import { $likec4model, IconRenderer as RenderIcon } from "likec4:single-project";
+import { LikeC4ModelProvider, LikeC4View, ReactLikeC4, useLikeC4Model, useLikeC4View } from "likec4:react";
 //#region codegen/react.tsx
-var s = e.get();
-function isLikeC4ViewId(e) {
-	return e != null && typeof e == "string" && !!s.findView(e);
+var likec4model = $likec4model.get();
+function isLikeC4ViewId(value) {
+	return value != null && typeof value === "string" && !!likec4model.findView(value);
 }
 //#endregion
-export { n as LikeC4ModelProvider, r as LikeC4View, i as ReactLikeC4, t as RenderIcon, isLikeC4ViewId, s as likec4model, a as useLikeC4Model, o as useLikeC4View };
+export { LikeC4ModelProvider, LikeC4View, ReactLikeC4, RenderIcon, isLikeC4ViewId, likec4model, useLikeC4Model, useLikeC4View };

package/__app__/codegen/webcomponent.mjs

@@ -1,107 +1,179 @@
 import "../src/chunks/rolldown-runtime.mjs";
-import { C as e, D as t, E as n, O as r, S as i, T as a, _ as o, b as s, d as c, f as l, g as u, h as d, l as f, m as p, p as m, u as h, v as g, w as _, x as v, y } from "../src/chunks/libs/zod.mjs";
-import { createRoot as b } from "react-dom/client";
-import { jsx as x } from "react/jsx-runtime";
-import { ComponentName as S } from "likec4:app-config";
-import { LikeC4View as C } from "likec4:react";
-//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/schemas.js
-var w = /*@__PURE__*/ r("ZodMiniType", (t, n) => {
-	if (!t._zod) throw Error("Uninitialized schema in ZodMiniType.");
-	y.init(t, n), t.def = n, t.type = n.type, t.parse = (e, n) => s(t, e, n, { callee: t.parse }), t.safeParse = (e, n) => i(t, e, n), t.parseAsync = async (e, n) => v(t, e, n, { callee: t.parseAsync }), t.safeParseAsync = async (n, r) => e(t, n, r), t.check = (...e) => t.clone({
-		...n,
-		checks: [...n.checks ?? [], ...e.map((e) => typeof e == "function" ? { _zod: {
-			check: e,
-			def: { check: "custom" },
-			onattach: []
-		} } : e)]
-	}, { parent: !0 }), t.with = t.check, t.clone = (e, n) => _(t, e, n), t.brand = () => t, t.register = ((e, n) => (e.add(t, n), t)), t.apply = (e) => e(t);
-}), T = /*@__PURE__*/ r("ZodMiniString", (e, t) => {
-	g.init(e, t), w.init(e, t);
+import { C as safeParseAsync, D as normalizeParams, E as installLazyProp, O as own, S as safeParse, T as clone, _ as $ZodPipe, b as parse, d as $ZodBoolean, f as $ZodCodec, g as $ZodOptional, h as $ZodObject, k as shallowClone, l as _string, m as $ZodLiteral, p as $ZodDefault, u as _stringbool, v as $ZodString, w as $constructor, x as parseAsync, y as $ZodType } from "../src/chunks/libs/zod.mjs";
+import { createRoot } from "react-dom/client";
+import { jsx } from "react/jsx-runtime";
+import { ComponentName } from "likec4:app-config";
+import { LikeC4View as LikeC4View$1 } from "likec4:react";
+//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/mini/schemas.js
+var ZodMiniType = /*@__PURE__*/ $constructor("ZodMiniType", (inst, def) => {
+	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
+	$ZodType.init(inst, def);
+	inst.def = def;
+	inst.type = def.type;
+}, {
+	get with() {
+		return this.check;
+	},
+	set with(value) {
+		own(this, "with", value);
+	},
+	parse(data, params) {
+		return parse(this, data, params, { callee: this.parse });
+	},
+	parseAsync(data, params) {
+		return parseAsync(this, data, params, { callee: this.parseAsync });
+	},
+	safeParse(data, params) {
+		return safeParse(this, data, params);
+	},
+	safeParseAsync(data, params) {
+		return safeParseAsync(this, data, params);
+	},
+	check(...checks) {
+		const def = this.def;
+		return this.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
+		}, { parent: true });
+	},
+	clone(_def, params) {
+		return clone(this, _def, params);
+	},
+	brand() {
+		return this;
+	},
+	register(reg, meta) {
+		reg.add(this, meta);
+		return this;
+	},
+	apply(fn, ...args) {
+		return args.length === 0 ? fn(this) : fn(this, ...args);
+	}
+});
+var ZodMiniString = /*@__PURE__*/ $constructor("ZodMiniString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodMiniType.init(inst, def);
 });
 // @__NO_SIDE_EFFECTS__
-function string(e) {
-	return f(T, e);
+function string(params) {
+	return _string(ZodMiniString, params);
 }
-var E = /*@__PURE__*/ r("ZodMiniBoolean", (e, t) => {
-	c.init(e, t), w.init(e, t);
-}), D = /*@__PURE__*/ r("ZodMiniObject", (e, t) => {
-	d.init(e, t), w.init(e, t), a(e, "shape", () => t.shape);
+var ZodMiniBoolean = /*@__PURE__*/ $constructor("ZodMiniBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+var ZodMiniObject = /*@__PURE__*/ $constructor("ZodMiniObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodMiniType.init(inst, def);
+	installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 });
 // @__NO_SIDE_EFFECTS__
-function object(e, t) {
-	return new D({
+function object(shape, params) {
+	return new ZodMiniObject({
 		type: "object",
-		shape: e ?? {},
-		...n(t)
+		shape: shape ?? {},
+		...normalizeParams(params)
 	});
 }
-var O = /*@__PURE__*/ r("ZodMiniLiteral", (e, t) => {
-	p.init(e, t), w.init(e, t);
+var ZodMiniLiteral = /*@__PURE__*/ $constructor("ZodMiniLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodMiniType.init(inst, def);
 });
 // @__NO_SIDE_EFFECTS__
-function literal(e, t) {
-	return new O({
+function literal(value, params) {
+	return new ZodMiniLiteral({
 		type: "literal",
-		values: Array.isArray(e) ? e : [e],
-		...n(t)
+		values: Array.isArray(value) ? value : [value],
+		...normalizeParams(params)
 	});
 }
-var k = /*@__PURE__*/ r("ZodMiniOptional", (e, t) => {
-	u.init(e, t), w.init(e, t);
+var ZodMiniOptional = /*@__PURE__*/ $constructor("ZodMiniOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodMiniType.init(inst, def);
 });
 // @__NO_SIDE_EFFECTS__
-function optional(e) {
-	return new k({
+function optional(innerType) {
+	return new ZodMiniOptional({
 		type: "optional",
-		innerType: e
+		innerType
 	});
 }
-var A = /*@__PURE__*/ r("ZodMiniDefault", (e, t) => {
-	m.init(e, t), w.init(e, t);
+var ZodMiniDefault = /*@__PURE__*/ $constructor("ZodMiniDefault", (inst, def) => {
+	$ZodDefault.init(inst, def);
+	ZodMiniType.init(inst, def);
 });
 // @__NO_SIDE_EFFECTS__
-function _default(e, n) {
-	return new A({
+function _default(innerType, defaultValue) {
+	return new ZodMiniDefault({
 		type: "default",
-		innerType: e,
+		innerType,
 		get defaultValue() {
-			return typeof n == "function" ? n() : t(n);
+			return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
 		}
 	});
 }
-var j = /*@__PURE__*/ r("ZodMiniPipe", (e, t) => {
-	o.init(e, t), w.init(e, t);
-}), M = /*@__PURE__*/ r("ZodMiniCodec", (e, t) => {
-	j.init(e, t), l.init(e, t);
-}), stringbool = (...e) => h({
-	Codec: M,
-	Boolean: E,
-	String: T
-}, ...e), N = /* @__PURE__ */ object({
+var ZodMiniPipe = /*@__PURE__*/ $constructor("ZodMiniPipe", (inst, def) => {
+	$ZodPipe.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+var ZodMiniCodec = /*@__PURE__*/ $constructor("ZodMiniCodec", (inst, def) => {
+	ZodMiniPipe.init(inst, def);
+	$ZodCodec.init(inst, def);
+});
+var stringbool = (...args) => _stringbool({
+	Codec: ZodMiniCodec,
+	Boolean: ZodMiniBoolean,
+	String: ZodMiniString
+}, ...args);
+//#endregion
+//#region codegen/webcomponent.tsx
+var propsSchema = /* @__PURE__ */ object({
 	viewId: /* @__PURE__ */ _default(/* @__PURE__ */ string(), "index"),
-	browser: /* @__PURE__ */ _default(stringbool(), !0),
+	browser: /* @__PURE__ */ _default(stringbool(), true),
 	dynamicViewVariant: /* @__PURE__ */ optional(/* @__PURE__ */ literal(["diagram", "sequence"])),
 	colorScheme: /* @__PURE__ */ optional(/* @__PURE__ */ literal(["light", "dark"]))
-}), LikeC4View = class extends HTMLElement {
+});
+var LikeC4View = class extends HTMLElement {
 	shadow;
 	root;
 	hostCss;
 	lastHostCss = "";
 	constructor() {
-		super(), this.shadow = this.attachShadow({
+		super();
+		this.shadow = this.attachShadow({
 			mode: "open",
-			delegatesFocus: !0
+			delegatesFocus: true
 		});
 	}
 	updateHostCss() {
-		let e = "\n    :host {\n      display: contents;\n      background-color: transparent;\n      margin: 0;\n      padding: 0;\n    }";
-		e !== this.lastHostCss && (this.hostCss?.replaceSync(e), this.lastHostCss = e);
+		const hostCss = `
+    :host {
+      display: contents;
+      background-color: transparent;
+      margin: 0;
+      padding: 0;
+    }`;
+		if (hostCss !== this.lastHostCss) {
+			this.hostCss?.replaceSync(hostCss);
+			this.lastHostCss = hostCss;
+		}
 	}
 	connectedCallback() {
-		this.lastHostCss = "", this.hostCss = new CSSStyleSheet(), this.updateHostCss(), this.shadow.adoptedStyleSheets = [this.hostCss], this.render();
+		this.lastHostCss = "";
+		this.hostCss = new CSSStyleSheet();
+		this.updateHostCss();
+		this.shadow.adoptedStyleSheets = [this.hostCss];
+		this.render();
 	}
 	disconnectedCallback() {
-		this.root?.unmount(), this.root = void 0, this.shadow.adoptedStyleSheets.length = 0, this.hostCss = void 0;
+		this.root?.unmount();
+		this.root = void 0;
+		this.shadow.adoptedStyleSheets.length = 0;
+		this.hostCss = void 0;
 	}
 	static observedAttributes = [
 		"view-id",
@@ -110,22 +182,28 @@ var j = /*@__PURE__*/ r("ZodMiniPipe", (e, t) => {
 		"color-scheme"
 	];
 	getProps() {
-		let e = N.safeParse({
+		const props = propsSchema.safeParse({
 			viewId: this.getAttribute("view-id"),
 			browser: this.getAttribute("browser") ?? void 0,
 			dynamicViewVariant: this.getAttribute("dynamic-variant") ?? void 0,
 			colorScheme: this.getAttribute("color-scheme") ?? void 0
 		});
-		return e.success ? e.data : (console.error("Invalid props", e.error), { viewId: "index" });
+		if (!props.success) {
+			console.error("Invalid props", props.error);
+			return { viewId: "index" };
+		}
+		return props.data;
 	}
 	render() {
-		let e = this.getProps();
-		this.updateHostCss(), this.root ??= b(this.shadow), this.root.render(/* @__PURE__ */ x(C, { ...e }));
+		const props = this.getProps();
+		this.updateHostCss();
+		this.root ??= createRoot(this.shadow);
+		this.root.render(/* @__PURE__ */ jsx(LikeC4View$1, { ...props }));
 	}
-	attributeChangedCallback(e) {
-		this.root && this.render();
+	attributeChangedCallback(_name) {
+		if (this.root) this.render();
 	}
 };
-customElements.define(S.View, LikeC4View);
+customElements.define(ComponentName.View, LikeC4View);
 //#endregion
 export { LikeC4View };

package/__app__/src/aichat/index.mjs

@@ -1,8 +1,13 @@
 import "../chunks/rolldown-runtime.mjs";
-import { Suspense as e, lazy as t } from "react";
-import { jsx as n } from "react/jsx-runtime";
-import { isAIAvailable as r } from "likec4:rpc";
+import { Suspense, lazy } from "react";
+import { jsx } from "react/jsx-runtime";
+import { isAIAvailable } from "likec4:rpc";
 //#region src/aichat/index.tsx
-var i = /* @__PURE__ */ t(() => import("../chunks/AIChat.mjs")), a = r ? () => /* @__PURE__ */ n(e, { children: /* @__PURE__ */ n(i, {}) }) : () => null;
+var AIChat = /* @__PURE__ */ lazy(() => import("../chunks/AIChat.mjs"));
+/**
+* AI Chat component that is conditionally rendered based on AI availability
+* Uses lazy loading to avoid importing AI components in environments where AI is not available
+*/
+var LazyAIChat = isAIAvailable ? () => /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(AIChat, {}) }) : () => null;
 //#endregion
-export { a as LazyAIChat };
+export { LazyAIChat };