@bravostudioai/react 0.1.0

package/dist/cli/commands/generate.js

@@ -0,0 +1,1526 @@
+import { mkdir as H, writeFile as q, readFile as R } from "fs/promises";
+import { join as k, dirname as ae } from "path";
+import { existsSync as B } from "fs";
+import ne from "../../_virtual/main.js";
+import { CONST_APPS_SERVICE_URL as oe, CONST_COMPONENTS_CDN_URL as re } from "../../packages/encore-lib/constants.js";
+ne.config();
+const G = process.env.APPS_SERVICE_URL || process.env.VITE_APPS_SERVICE_URL || oe;
+console.log(`Using APPS_SERVICE_URL: ${G}`);
+const se = re;
+async function V(h, l) {
+  const o = await fetch(h, {
+    headers: l || {}
+  });
+  if (!o.ok)
+    throw new Error(
+      `Failed to download ${h}: ${o.status} ${o.statusText}`
+    );
+  return await o.text();
+}
+function M(h) {
+  const l = h.replace(/[^a-zA-Z0-9\s]/g, "").trim();
+  return l ? l.split(/\s+/).map((o, d) => {
+    if (!o) return "";
+    const e = o === o.toUpperCase() && o.length > 1 ? o.toLowerCase() : o, p = e.charAt(0), n = e.slice(1);
+    return d === 0 ? p.toLowerCase() + n : p.toUpperCase() + n;
+  }).join("").replace(/^[0-9]/, "_$&") : "item";
+}
+function L(h, l) {
+  const o = M(h);
+  if (l.length === 0)
+    return o;
+  const d = l.filter((n) => n && n.trim()).reverse();
+  return d.length === 0 ? o : d.map(
+    (n) => M(n)
+  ).map((n) => n.charAt(0).toUpperCase() + n.slice(1)).join("") + o;
+}
+function z(h, l) {
+  if (l.length === 0)
+    return [];
+  let o = 0;
+  const d = Math.min(
+    h.length,
+    ...l.map((p) => p.length)
+  );
+  for (let p = 0; p < d; p++) {
+    const n = h[p];
+    if (l.every((g) => g[p] === n))
+      o++;
+    else
+      break;
+  }
+  const e = h.slice(o);
+  for (let p = 1; p <= e.length; p++) {
+    const n = e.slice(0, p);
+    if (l.every((g) => {
+      if (g.length < o + p)
+        return !0;
+      const c = g.slice(
+        o,
+        o + p
+      );
+      return !Q(n, c);
+    }))
+      return n;
+  }
+  return e;
+}
+function Q(h, l) {
+  return h.length !== l.length ? !1 : h.every((o, d) => o === l[d]);
+}
+function J(h, l) {
+  return h === "component:image" || h === "component:text" || h?.startsWith("component:input-") ? "string" : "any";
+}
+function Y(h) {
+  return h === "component:image" ? "imageUrl" : h === "component:text" ? "text" : "value";
+}
+function ie(h) {
+  const l = [];
+  function o(e, p = []) {
+    if (!(!e || typeof e != "object")) {
+      if (e.type === "container:slider") {
+        let n = function(c) {
+          if (!g && !(!c || typeof c != "object")) {
+            if (Array.isArray(c.tags) && (c.tags.includes("encore:data:array") || c.tags.includes("bravo:data:array"))) {
+              g = c;
+              return;
+            }
+            c.body && Array.isArray(c.body) && c.body.forEach(n), c.containers && Array.isArray(c.containers) && c.containers.forEach(n), c.components && Array.isArray(c.components) && c.components.forEach(n);
+          }
+        };
+        const i = {
+          id: e.id,
+          name: e.name || "Slider",
+          arrayContainer: null
+        };
+        let g = null;
+        if (e.containers && Array.isArray(e.containers) && e.containers.forEach(n), !g && e.components && Array.isArray(e.components) && e.components.forEach(n), g) {
+          let c = function(f, $ = []) {
+            if (!f || typeof f != "object") return;
+            if (f.type === "component:image" && N.push(f), Array.isArray(f.tags) && (f.tags.includes("encore:data") || f.tags.includes("bravo:data"))) {
+              const x = M(f.name || "item"), _ = J(f.type, f.name);
+              m.push({
+                id: f.id,
+                name: f.name || "Unnamed",
+                type: f.type,
+                tags: f.tags || [],
+                propName: x,
+                // Will be qualified later if needed
+                propType: _,
+                // Store parent path for later qualification
+                _parentPath: [...$]
+              });
+            }
+            const A = [...$];
+            if (f.name && (f.type?.startsWith("container:") || f.type?.startsWith("component:"))) {
+              const x = f.name.trim(), _ = /^frame\s*\d*$/i.test(x) || x.toUpperCase() === "FRAME";
+              x && !_ && A.push(f.name);
+            }
+            f.components && Array.isArray(f.components) && f.components.forEach(
+              (x) => c(x, A)
+            );
+          };
+          const y = g;
+          let m = [];
+          const N = [];
+          if (y.components && Array.isArray(y.components) && y.components.forEach(
+            (f) => c(f, [])
+          ), !m.some(
+            (f) => f.type === "component:image"
+          ) && N.length > 0) {
+            const f = N[0], A = (f.name || "image").toLowerCase().includes("image") ? "imageUrl" : M(f.name || "image");
+            m.push({
+              id: f.id,
+              name: f.name || "Image",
+              type: f.type,
+              tags: f.tags || [],
+              propName: A,
+              // Will be qualified later if needed
+              propType: "string",
+              // imageUrl is always string
+              _parentPath: []
+            });
+          }
+          const C = /* @__PURE__ */ new Map();
+          if (m.forEach((f) => {
+            const $ = f, A = f.propName;
+            C.has(A) || C.set(A, []), C.get(A).push($);
+          }), C.forEach((f, $) => {
+            if (f.length === 1)
+              return;
+            f.forEach((v) => {
+              const U = f.filter((w) => w.id !== v.id).map((w) => w._parentPath || []), j = z(
+                v._parentPath || [],
+                U
+              );
+              v.propName = L(
+                v.name || "item",
+                j
+              );
+            });
+            let A = !0, x = 0;
+            const _ = 10;
+            for (; A && x < _; ) {
+              x++;
+              const v = /* @__PURE__ */ new Map();
+              f.forEach((U) => {
+                v.has(U.propName) || v.set(U.propName, []), v.get(U.propName).push(U);
+              }), A = !1, v.forEach((U, j) => {
+                U.length > 1 && (A = !0, U.forEach((w) => {
+                  const T = w._parentPath || [], a = U.filter((t) => t.id !== w.id).map((t) => t._parentPath || []);
+                  let b = 0;
+                  const D = Math.min(
+                    T.length,
+                    ...a.map((t) => t.length)
+                  );
+                  for (let t = 0; t < D; t++) {
+                    const u = T[t];
+                    if (a.every((I) => I[t] === u))
+                      b++;
+                    else
+                      break;
+                  }
+                  const s = T.slice(b);
+                  let E = !1;
+                  for (let t = 1; t <= s.length; t++) {
+                    const u = s.slice(
+                      0,
+                      t
+                    ), P = L(
+                      w.name || "item",
+                      u
+                    );
+                    if (m.every((F) => {
+                      if (F.id === w.id) return !0;
+                      if (U.some((O) => O.id === F.id)) {
+                        const O = F._parentPath || [], W = Math.min(
+                          b,
+                          O.length
+                        ), ee = O.slice(
+                          W
+                        ).slice(0, t), te = L(
+                          F.name || "item",
+                          ee
+                        );
+                        return P !== te;
+                      }
+                      return P !== F.propName;
+                    })) {
+                      w.propName = P, E = !0;
+                      break;
+                    }
+                  }
+                  E || (w.propName = L(
+                    w.name || "item",
+                    s.length > 0 ? s : []
+                  ));
+                }));
+              });
+            }
+            const S = /* @__PURE__ */ new Map();
+            f.forEach((v) => {
+              S.has(v.propName) || S.set(v.propName, []), S.get(v.propName).push(v);
+            }), S.forEach(
+              (v, U) => {
+                if (v.length > 1 && v.every((w) => {
+                  const T = w._parentPath || [];
+                  return v.every((a) => {
+                    if (a.id === w.id) return !0;
+                    const b = a._parentPath || [];
+                    return Q(T, b);
+                  });
+                })) {
+                  let w = 0;
+                  v.forEach((T) => {
+                    w > 0 && (T.propName = `${U}${w + 1}`), w++;
+                  });
+                }
+              }
+            ), f.forEach((v) => {
+              delete v._parentPath;
+            });
+          }), N.length > 0) {
+            const $ = (N[0].name || "").toLowerCase();
+            m = m.filter((A) => {
+              if (A.type === "component:image") return !0;
+              if (A.type === "component:color") {
+                const x = (A.name || "").toLowerCase();
+                if ($.includes(x) || x.includes("image"))
+                  return !1;
+              }
+              return !0;
+            });
+          }
+          i.arrayContainer = {
+            id: y.id,
+            name: y.name || "Item",
+            propName: M(y.name || "items"),
+            components: m
+          };
+        }
+        l.push(i);
+      }
+      e.body && Array.isArray(e.body) && e.body.forEach((n) => o(n, [...p, "body"])), e.containers && Array.isArray(e.containers) && e.containers.forEach(
+        (n) => o(n, [...p, "containers"])
+      ), e.components && Array.isArray(e.components) && e.components.forEach(
+        (n) => o(n, [...p, "components"])
+      );
+    }
+  }
+  const d = h.data?.body || h.body || h.data?.body || [];
+  return Array.isArray(d) && d.length > 0 && d.forEach((e) => o(e)), l;
+}
+function pe(h) {
+  const l = [], o = /* @__PURE__ */ new Set();
+  function d(i) {
+    !i || typeof i != "object" || (i.type === "container:slider" && o.add(i.id), i.body && Array.isArray(i.body) && i.body.forEach(d), i.containers && Array.isArray(i.containers) && i.containers.forEach(d));
+  }
+  function e(i, g, c = []) {
+    if (!i || typeof i != "object" || g && o.has(g)) return;
+    if (Array.isArray(i.tags) && (i.tags.includes("encore:data") || i.tags.includes("bravo:data")) && (i.type === "component:text" || i.type === "component:image")) {
+      const N = M(i.name || "item"), r = J(i.type, i.name);
+      l.push({
+        id: i.id,
+        name: i.name || "Unnamed",
+        type: i.type,
+        tags: i.tags || [],
+        propName: N,
+        // Will be qualified later if needed
+        propType: r,
+        // Store parent path for later qualification
+        _parentPath: [...c]
+      });
+    }
+    const y = [...c];
+    if (i.name && (i.type?.startsWith("container:") || i.type?.startsWith("component:"))) {
+      const N = i.name.trim(), r = /^frame\s*\d*$/i.test(N) || N.toUpperCase() === "FRAME";
+      N && !r && y.push(i.name);
+    }
+    const m = i.id;
+    i.body && Array.isArray(i.body) && i.body.forEach(
+      (N) => e(N, m, y)
+    ), i.containers && Array.isArray(i.containers) && i.containers.forEach(
+      (N) => e(N, m, y)
+    ), i.components && Array.isArray(i.components) && i.components.forEach(
+      (N) => e(N, m, y)
+    );
+  }
+  const p = h.data?.body || h.body || h.data?.body || [];
+  Array.isArray(p) && p.length > 0 && (p.forEach(d), p.forEach((i) => e(i)));
+  const n = /* @__PURE__ */ new Map();
+  return l.forEach((i) => {
+    const g = i, c = i.propName;
+    n.has(c) || n.set(c, []), n.get(c).push(g);
+  }), n.forEach((i, g) => {
+    if (i.length === 1)
+      return;
+    i.forEach((r) => {
+      const C = i.filter(($) => $.id !== r.id).map(($) => $._parentPath || []), f = z(
+        r._parentPath || [],
+        C
+      );
+      r.propName = L(
+        r.name || "item",
+        f
+      );
+    });
+    let c = !0, y = 0;
+    const m = 10;
+    for (; c && y < m; ) {
+      y++;
+      const r = /* @__PURE__ */ new Map();
+      i.forEach((C) => {
+        r.has(C.propName) || r.set(C.propName, []), r.get(C.propName).push(C);
+      }), c = !1, r.forEach((C, f) => {
+        C.length > 1 && (c = !0, C.forEach(($) => {
+          const A = $._parentPath || [], x = C.filter((j) => j.id !== $.id).map((j) => j._parentPath || []);
+          let _ = 0;
+          const S = Math.min(
+            A.length,
+            ...x.map((j) => j.length)
+          );
+          for (let j = 0; j < S; j++) {
+            const w = A[j];
+            if (x.every((a) => a[j] === w))
+              _++;
+            else
+              break;
+          }
+          const v = A.slice(_);
+          let U = !1;
+          for (let j = 1; j <= v.length; j++) {
+            const w = v.slice(0, j), T = L(
+              $.name || "item",
+              w
+            );
+            if (l.every((b) => {
+              if (b.id === $.id) return !0;
+              if (C.some((D) => D.id === b.id)) {
+                const D = b._parentPath || [], s = Math.min(
+                  _,
+                  D.length
+                ), t = D.slice(
+                  s
+                ).slice(
+                  0,
+                  j
+                ), u = L(
+                  b.name || "item",
+                  t
+                );
+                return T !== u;
+              }
+              return T !== b.propName;
+            })) {
+              $.propName = T, U = !0;
+              break;
+            }
+          }
+          U || ($.propName = L(
+            $.name || "item",
+            A
+          ));
+        }));
+      });
+    }
+    const N = /* @__PURE__ */ new Map();
+    i.forEach((r) => {
+      N.has(r.propName) || N.set(r.propName, []), N.get(r.propName).push(r);
+    }), N.forEach((r, C) => {
+      if (r.length > 1 && r.every(($) => {
+        const A = $._parentPath || [];
+        return r.every((x) => {
+          if (x.id === $.id) return !0;
+          const _ = x._parentPath || [];
+          return Q(A, _);
+        });
+      })) {
+        let $ = 0;
+        r.forEach((A) => {
+          $ > 0 && (A.propName = `${C}${$ + 1}`), $++;
+        });
+      }
+    }), i.forEach((r) => {
+      delete r._parentPath;
+    });
+  }), l;
+}
+function ce(h) {
+  const l = /* @__PURE__ */ new Map();
+  function o(e) {
+    if (!(!e || typeof e != "object")) {
+      if (e.type === "component:input-stateful-set" && Array.isArray(e.tags)) {
+        const p = e.tags.find(
+          (n) => n.startsWith("input-group:")
+        );
+        if (p) {
+          const n = p.split(":");
+          if (n.length >= 3) {
+            const i = n[1], g = n[2];
+            l.has(g) || l.set(g, {
+              groupName: g,
+              groupType: i,
+              elements: []
+            }), l.get(g).elements.push({
+              id: e.id,
+              name: e.name || "Unnamed"
+            });
+          }
+        }
+      }
+      e.body && Array.isArray(e.body) && e.body.forEach(o), e.containers && Array.isArray(e.containers) && e.containers.forEach(o), e.components && Array.isArray(e.components) && e.components.forEach(o);
+    }
+  }
+  const d = h.data?.body || h.body || h.data?.body || [];
+  return Array.isArray(d) && d.length > 0 && d.forEach((e) => o(e)), Array.from(l.values());
+}
+function le(h) {
+  const l = [];
+  function o(e, p) {
+    if (!e || typeof e != "object") return;
+    const n = e.type?.startsWith("container:") || e.type === "container:default", i = e.name?.toLowerCase().includes("form") || Array.isArray(e.tags) && e.tags.includes("form");
+    let g = !1, c;
+    function y(m) {
+      if (!(!m || typeof m != "object")) {
+        if (Array.isArray(m.tags) && (m.tags.includes("action:submit") || m.tags.includes("submit"))) {
+          g = !0, c = m.id;
+          return;
+        }
+        if (m.actions?.tap?.action === "submit") {
+          g = !0, c = m.id;
+          return;
+        }
+        m.components && Array.isArray(m.components) && m.components.forEach(y), m.body && Array.isArray(m.body) && m.body.forEach(y);
+      }
+    }
+    if (n && (i || p === void 0) && y(e), n && (g || i)) {
+      let m = function(r, C = []) {
+        if (!r || typeof r != "object") return;
+        if (r.type?.startsWith("component:input-") || r.type === "component:input-text" || r.type === "component:input-image" || r.type === "component:input-email" || r.type === "component:input-password" || r.type === "component:input-select") {
+          const $ = M(r.name || "Unnamed input");
+          N.push({
+            id: r.id,
+            name: r.name || "Unnamed input",
+            type: r.type,
+            propName: $,
+            // Will be qualified later if needed
+            _parentPath: [...C]
+            // Store parent path for qualification
+          });
+        }
+        const f = [...C];
+        if (r.name && (r.type?.startsWith("container:") || r.type?.startsWith("component:"))) {
+          const $ = r.name.trim(), A = /^frame\s*\d*$/i.test($) || $.toUpperCase() === "FRAME";
+          $ && !A && f.push(r.name);
+        }
+        r.components && Array.isArray(r.components) && r.components.forEach(
+          ($) => m($, f)
+        ), r.body && Array.isArray(r.body) && r.body.forEach(($) => m($, f));
+      };
+      const N = [];
+      m(e, []), N.length > 0 && l.push({
+        formId: e.id,
+        formName: e.name || "Form",
+        submitButtonId: c,
+        inputs: N
+      });
+    }
+    e.body && Array.isArray(e.body) && e.body.forEach(
+      (m) => o(m, n ? e : p)
+    ), e.containers && Array.isArray(e.containers) && e.containers.forEach(
+      (m) => o(m, n ? e : p)
+    ), e.components && Array.isArray(e.components) && e.components.forEach(
+      (m) => o(m, n ? e : p)
+    );
+  }
+  const d = h.data?.body || h.body || h.data?.body || [];
+  return Array.isArray(d) && d.length > 0 && d.forEach((e) => o(e)), l;
+}
+function he(h, l) {
+  const o = [], d = /* @__PURE__ */ new Set();
+  l.forEach((n) => {
+    n.inputs.forEach((i) => {
+      d.add(i.id);
+    });
+  });
+  function e(n, i = []) {
+    if (!n || typeof n != "object") return;
+    if (n.type === "component:input-select" && !d.has(n.id)) {
+      const c = M(n.name || "selectInput");
+      o.push({
+        id: n.id,
+        name: n.name || "Select Input",
+        propName: c,
+        _parentPath: [...i]
+      });
+    }
+    const g = [...i];
+    if (n.name && (n.type?.startsWith("container:") || n.type?.startsWith("component:"))) {
+      const c = n.name.trim(), y = /^frame\s*\d*$/i.test(c) || c.toUpperCase() === "FRAME";
+      c && !y && g.push(n.name);
+    }
+    n.body && Array.isArray(n.body) && n.body.forEach((c) => e(c, g)), n.containers && Array.isArray(n.containers) && n.containers.forEach(
+      (c) => e(c, g)
+    ), n.components && Array.isArray(n.components) && n.components.forEach(
+      (c) => e(c, g)
+    );
+  }
+  const p = h.data?.body || h.body || h.data?.body || [];
+  return Array.isArray(p) && p.length > 0 && p.forEach((n) => e(n)), me(o), o;
+}
+function me(h) {
+  const l = /* @__PURE__ */ new Map();
+  h.forEach((o) => {
+    const d = o, e = o.propName;
+    l.has(e) || l.set(e, []), l.get(e).push(d);
+  }), l.forEach((o, d) => {
+    if (o.length === 1) {
+      delete o[0]._parentPath;
+      return;
+    }
+    o.forEach((e) => {
+      const p = o.filter((i) => i.id !== e.id).map((i) => i._parentPath || []), n = z(
+        e._parentPath || [],
+        p
+      );
+      e.propName = L(
+        e.name || "input",
+        n
+      );
+    }), o.forEach((e) => {
+      delete e._parentPath;
+    });
+  });
+}
+function fe(h) {
+  const l = [];
+  function o(e, p = []) {
+    if (!e || typeof e != "object") return;
+    const n = Array.isArray(e.tags) && e.tags.some((c) => c.startsWith("action:")), i = e.actions && typeof e.actions == "object";
+    if (n || i) {
+      let c = "tap";
+      if (Array.isArray(e.tags)) {
+        const m = e.tags.find(
+          (N) => N.startsWith("action:")
+        );
+        m && (c = m.replace("action:", ""));
+      }
+      e.actions?.tap?.action && (c = e.actions.tap.action);
+      const y = M(e.name || "button");
+      l.push({
+        id: e.id,
+        name: e.name || "Button",
+        propName: y,
+        actionType: c,
+        _parentPath: [...p]
+      });
+    }
+    const g = [...p];
+    if (e.name && (e.type?.startsWith("container:") || e.type?.startsWith("component:"))) {
+      const c = e.name.trim(), y = /^frame\s*\d*$/i.test(c) || c.toUpperCase() === "FRAME";
+      c && !y && g.push(e.name);
+    }
+    e.body && Array.isArray(e.body) && e.body.forEach((c) => o(c, g)), e.containers && Array.isArray(e.containers) && e.containers.forEach(
+      (c) => o(c, g)
+    ), e.components && Array.isArray(e.components) && e.components.forEach(
+      (c) => o(c, g)
+    );
+  }
+  const d = h.data?.body || h.body || h.data?.body || [];
+  return Array.isArray(d) && d.length > 0 && d.forEach((e) => o(e)), ue(l), l;
+}
+function ue(h) {
+  const l = /* @__PURE__ */ new Map();
+  h.forEach((o) => {
+    const d = o, e = o.propName;
+    l.has(e) || l.set(e, []), l.get(e).push(d);
+  }), l.forEach((o, d) => {
+    if (o.length === 1) {
+      delete o[0]._parentPath;
+      return;
+    }
+    o.forEach((e) => {
+      const p = o.filter((i) => i.id !== e.id).map((i) => i._parentPath || []), n = z(
+        e._parentPath || [],
+        p
+      );
+      e.propName = L(
+        e.name || "button",
+        n
+      );
+    }), o.forEach((e) => {
+      delete e._parentPath;
+    });
+  });
+}
+function de(h) {
+  h.forEach((l) => {
+    const o = l.inputs, d = /* @__PURE__ */ new Map();
+    o.forEach((e) => {
+      const p = e, n = e.propName;
+      d.has(n) || d.set(n, []), d.get(n).push(p);
+    }), d.forEach((e, p) => {
+      if (e.length === 1) {
+        delete e[0]._parentPath;
+        return;
+      }
+      e.forEach((y) => {
+        const m = e.filter((r) => r.id !== y.id).map((r) => r._parentPath || []), N = z(
+          y._parentPath || [],
+          m
+        );
+        y.propName = L(
+          y.name || "input",
+          N
+        );
+      });
+      let n = !0, i = 0;
+      const g = 10;
+      for (; n && i < g; ) {
+        i++;
+        const y = /* @__PURE__ */ new Map();
+        e.forEach((m) => {
+          y.has(m.propName) || y.set(m.propName, []), y.get(m.propName).push(m);
+        }), n = !1, y.forEach((m, N) => {
+          m.length > 1 && (n = !0, m.forEach((r) => {
+            const C = r._parentPath || [], f = m.filter((S) => S.id !== r.id).map((S) => S._parentPath || []);
+            let $ = 0;
+            const A = Math.min(
+              C.length,
+              ...f.map((S) => S.length)
+            );
+            for (let S = 0; S < A; S++) {
+              const v = C[S];
+              if (f.every((j) => j[S] === v))
+                $++;
+              else
+                break;
+            }
+            const x = C.slice($);
+            let _ = !1;
+            for (let S = 1; S <= x.length; S++) {
+              const v = x.slice(
+                0,
+                S
+              ), U = L(
+                r.name || "input",
+                v
+              );
+              if (o.every((w) => {
+                if (w.id === r.id) return !0;
+                if (m.some((T) => T.id === w.id)) {
+                  const T = w._parentPath || [], a = Math.min(
+                    $,
+                    T.length
+                  ), D = T.slice(
+                    a
+                  ).slice(
+                    0,
+                    S
+                  ), s = L(
+                    w.name || "input",
+                    D
+                  );
+                  return U !== s;
+                }
+                return U !== w.propName;
+              })) {
+                r.propName = U, _ = !0;
+                break;
+              }
+            }
+            _ || (r.propName = L(
+              r.name || "input",
+              x.length > 0 ? x : []
+            ));
+          }));
+        });
+      }
+      const c = /* @__PURE__ */ new Map();
+      e.forEach((y) => {
+        c.has(y.propName) || c.set(y.propName, []), c.get(y.propName).push(y);
+      }), c.forEach((y, m) => {
+        if (y.length > 1 && y.every((r) => {
+          const C = r._parentPath || [];
+          return y.every((f) => {
+            if (f.id === r.id) return !0;
+            const $ = f._parentPath || [];
+            return Q(C, $);
+          });
+        })) {
+          let r = 0;
+          y.forEach((C) => {
+            r > 0 && (C.propName = `${m}${r + 1}`), r++;
+          });
+        }
+      }), e.forEach((y) => {
+        delete y._parentPath;
+      });
+    });
+  });
+}
+function ge(h, l, o, d, e, p, n, i, g, c = !1) {
+  const y = [], m = [], N = [], r = [], C = [], f = [];
+  e.forEach((t) => {
+    y.push(`  ${t.propName}?: ${t.propType};`);
+  }), p.forEach((t) => {
+    const u = M(t.groupName);
+    N.push(`  ${u}?: string;`), N.push(
+      `  on${u[0].toUpperCase()}${u.slice(
+        1
+      )}Change?: (value: string) => void;`
+    );
+  });
+  const $ = [];
+  n.forEach((t) => {
+    const u = M(t.formName), P = `${u[0].toUpperCase()}${u.slice(
+      1
+    )}FormData`, I = [];
+    t.inputs.forEach((F) => {
+      const O = F.propName, W = J(F.type, F.name);
+      I.push(`  ${O}: ${W};`);
+    }), $.push(`export interface ${P} {
+${I.join(`
+`)}
+}`), r.push(
+      `  on${u[0].toUpperCase()}${u.slice(
+        1
+      )}Submit?: (formData: ${P}) => void;`
+    );
+  }), i.forEach((t) => {
+    const u = t.propName, P = u[0].toUpperCase() + u.slice(1);
+    C.push(`  ${u}?: string;`), C.push(
+      `  ${u}Options?: Array<string | { value: string; label: string }>;`
+    ), C.push(
+      `  on${P}Change?: (value: string) => void;`
+    );
+  }), g.forEach((t) => {
+    const u = t.propName, P = u[0].toUpperCase() + u.slice(1);
+    f.push(`  on${P}Click?: () => void;`);
+  }), d.forEach((t) => {
+    if (t.arrayContainer && t.arrayContainer.components.length > 0) {
+      const P = t.arrayContainer, I = `${P.propName[0].toUpperCase()}${P.propName.slice(
+        1
+      )}Item`;
+      y.push(`  ${P.propName}: ${I}[];`);
+    }
+    const u = M(t.name || "container");
+    m.push(`  ${u}CurrentIndex?: number;`), m.push(
+      `  on${u[0].toUpperCase()}${u.slice(
+        1
+      )}IndexChange?: (index: number) => void;`
+    );
+  });
+  const A = [
+    ...y,
+    ...m,
+    ...N,
+    ...r,
+    ...C,
+    ...f
+  ], x = A.length > 0, _ = x ? `export interface ${o}Props {
+${A.join(`
+`)}
+}` : "", S = d.filter((t) => t.arrayContainer && t.arrayContainer.components.length > 0).map((t) => {
+    const u = t.arrayContainer, P = `${u.propName[0].toUpperCase()}${u.propName.slice(
+      1
+    )}Item`, I = u.components.map((F) => `  ${F.propName}: ${F.propType};`).join(`
+`);
+    return `export interface ${P} {
+${I}
+}`;
+  }).join(`
+
+`), v = $.join(`
+
+`), U = [], j = [];
+  e.forEach((t) => {
+    const u = Y(t.type);
+    U.push(`    // ${t.name}
+    ...(props.${t.propName} !== undefined && { "${t.id}": { ${u}: props.${t.propName} } as any }),`);
+  }), i.forEach((t) => {
+    U.push(`    // ${t.name}
+    ...((props.${t.propName} !== undefined || props.${t.propName}Options !== undefined) && { 
+      "${t.id}": { 
+        ...(props.${t.propName} !== undefined && { value: props.${t.propName} }),
+        ...(props.${t.propName}Options !== undefined && { options: props.${t.propName}Options }),
+      } as any 
+    }),`);
+  }), d.forEach((t) => {
+    if (t.arrayContainer && t.arrayContainer.components.length > 0) {
+      const F = t.arrayContainer, O = F.components.map((W) => {
+        const K = Y(W.type);
+        return `        // ${W.name}
+        "${W.id}": {
+          ${K}: item.${W.propName},
+        }`;
+      }).join(`,
+`);
+      U.push(`    // ${F.name}
+    "${F.id}": props.${F.propName}.map((item) => ({
+${O}
+      })),`);
+    }
+    const u = M(t.name || "container"), P = `${u[0].toUpperCase()}${u.slice(
+      1
+    )}IndexChange`, I = [];
+    t.id && (I.push(`      // ${t.name}`), I.push(`      "${t.id}": {`), I.push(
+      `        currentIndex: props.${u}CurrentIndex,`
+    ), I.push(`        onIndexChange: props.on${P},`), I.push("      }")), I.length > 0 && j.push(I.join(`
+`));
+  });
+  const w = j.length > 0 ? `
+      repeatingContainerControls={{
+${j.join(`,
+`)}
+      }}` : "", T = [], a = [];
+  (p.length > 0 || n.length > 0 || i.length > 0 || g.length > 0) && (a.push("  const handleAction = (payload: any) => {"), a.push("    const { action } = payload?.bravo || {};"), a.push(""), i.length > 0 && (a.push("    // Handle select input changes"), a.push(
+    '    if (action?.action === "input-change" || action?.action === "select-change") {'
+  ), a.push("      const nodeId = action?.nodeId;"), a.push("      const value = action?.params?.value;"), a.push(""), i.forEach((t) => {
+    const u = t.propName, I = `on${u[0].toUpperCase() + u.slice(1)}Change`;
+    a.push(`      // ${t.name}`), a.push(
+      `      if (nodeId === "${t.id}" && props.${I}) {`
+    ), a.push(`        props.${I}(value);`), a.push("        return;"), a.push("      }");
+  }), a.push("    }"), a.push("")), g.length > 0 && (a.push("    // Handle button clicks"), a.push(
+    '    if (action?.action === "remote" || action?.action === "tap" || action?.action === "link") {'
+  ), a.push("      const nodeId = action?.nodeId;"), a.push(""), g.forEach((t) => {
+    const u = t.propName, I = `on${u[0].toUpperCase() + u.slice(1)}Click`;
+    a.push(`      // ${t.name}`), a.push(
+      `      if (nodeId === "${t.id}" && props.${I}) {`
+    ), a.push(`        props.${I}();`), a.push("        return;"), a.push("      }");
+  }), a.push("    }"), a.push("")), p.length > 0 && (a.push(
+    '    if (action?.action === "input-group-change") {'
+  ), a.push(
+    "      const { groupName, value } = action.params;"
+  ), p.forEach((t) => {
+    const u = M(t.groupName), P = `on${u[0].toUpperCase()}${u.slice(
+      1
+    )}Change`;
+    a.push(
+      `      if (groupName === "${t.groupName}" && props.${P}) {`
+    ), a.push(`        props.${P}(value);`), a.push("        return;"), a.push("      }");
+  }), a.push("    }"), a.push("")), n.length > 0 && (a.push('    if (action?.action === "submit") {'), a.push("      // Get form inputs from Encore state"), a.push(
+    `      const formInputs = useEncoreState.getState().formInputs["${l}"] || {};`
+  ), a.push("      const submitNodeId = action?.nodeId;"), a.push(""), n.forEach((t, u) => {
+    const P = M(t.formName), I = `on${P[0].toUpperCase()}${P.slice(
+      1
+    )}Submit`;
+    u > 0 && a.push(""), a.push(
+      `      // Form: ${t.formName} (${t.formId})`
+    ), t.submitButtonId ? a.push(
+      `      if (submitNodeId === "${t.submitButtonId}" && props.${I}) {`
+    ) : n.length === 1 ? a.push(`      if (props.${I}) {`) : a.push(`      if (props.${I}) {`), a.push("        // Extract form inputs for this form");
+    const F = `${P[0].toUpperCase()}${P.slice(
+      1
+    )}FormData`;
+    a.push(
+      `        const formData: ${F} = {`
+    );
+    const O = [];
+    t.inputs.forEach((W) => {
+      const K = W.propName;
+      O.push(
+        `          ${K}: formInputs["${W.id}"]`
+      );
+    }), a.push(O.join(`,
+`)), a.push("        };"), a.push(`        props.${I}(formData);`), a.push(
+      "        // Note: Default form submission will still proceed after callback"
+    ), a.push("      }");
+  }), a.push("    }")), a.push("  };")), p.forEach((t) => {
+    const u = M(t.groupName);
+    T.push(
+      `    ...(props.${u} !== undefined && { ${u}: props.${u} }),`
+    );
+  });
+  const b = T.length > 0 ? `
+      inputGroups={{
+${T.join(`
+`)}
+      }}` : "", D = a.length > 0 ? `
+      onAction={handleAction}` : "", s = x ? `props: ${o}Props` : "", E = _ ? `${_}
+
+` : "";
+  return `/**
+ * ${o}
+ * 
+ * Wrapper component for Encore Studio app.
+ * See README.md for detailed documentation.
+ */
+
+import { EncoreApp${n.length > 0 ? ", useEncoreState" : ""} } from "@bravostudioai/react";
+${c ? 'import productionData from "./data.json";' : ""}
+
+${S ? `${S}
+
+` : ""}${v ? `${v}
+
+` : ""}${E}export function ${o}(${s}) {
+${a.length > 0 ? a.join(`
+`) : ""}
+  return (
+    <EncoreApp
+      appId="${h}"
+      pageId="${l}"
+      ${c ? `appDefinition={productionData.app}
+      pageDefinition={productionData.page}
+      componentCode={productionData.componentCode}` : ""}
+      data={{
+${U.join(`
+`)}
+      }}${w}${b}${D}
+    />
+  );
+}
+
+export default ${o};
+`;
+}
+function ye(h, l, o, d, e, p, n, i, g, c, y) {
+  const m = [], N = [], r = [], C = [];
+  n.forEach((a) => {
+    m.push(`### \`${a.propName}\` (${a.propType}, optional)
+
+${a.name} (${a.type}) - Component ID: ${a.id}`);
+  }), p.forEach((a) => {
+    if (a.arrayContainer && a.arrayContainer.components.length > 0) {
+      const s = a.arrayContainer, E = s.components.map((t) => `- \`${t.propName}\` (${t.propType}): ${t.name} (${t.type}) - Component ID: ${t.id}`).join(`
+`);
+      m.push(`### \`${s.propName}\` (${s.propName[0].toUpperCase()}${s.propName.slice(
+        1
+      )}Item[])
+
+Array of items for "${s.name}" container (ID: ${s.id})
+
+**Properties:**
+
+${E}`);
+    }
+    const b = M(a.name || "container"), D = `${b[0].toUpperCase()}${b.slice(
+      1
+    )}IndexChange`;
+    N.push(`### \`${b}CurrentIndex\` (number, optional)
+
+Controls the currently visible slide/index for the "${a.name}" container (ID: ${a.id}).
+
+When provided, the slider operates in controlled mode - the parent component controls which slide is displayed. When not provided, the slider manages its own state.
+
+### \`on${D}\` ((index: number) => void, optional)
+
+Callback fired when the user navigates to a different slide. Called with the new slide index (0-based).
+
+This event fires whenever the slide changes, whether by user interaction, automatic advancement, or programmatic control.`);
+  });
+  const f = m.length > 0 ? m.join(`
+
+`) : "This component currently has no data-bound props.", $ = N.length > 0 ? `## Control Props
+
+These props allow you to imperatively control repeating containers (sliders, lists, etc.) and receive notifications when the current index changes.
+
+${N.join(`
+
+`)}` : "", A = [];
+  i.forEach((a) => {
+    const b = M(a.groupName), D = `on${b[0].toUpperCase()}${b.slice(
+      1
+    )}Change`, s = a.elements.map((E) => `- "${E.name}"`).join(`
+`);
+    A.push(`### \`${b}\` (string, optional)
+
+Sets which element is active in the "${a.groupName}" input group (type: ${a.groupType}).
+
+**Available elements:**
+${s}
+
+### \`${D}\` ((value: string) => void, optional)
+
+Callback fired when the user selects a different element in the "${a.groupName}" input group. Called with the name of the selected element.`);
+  });
+  const x = A.length > 0 ? `## Input Group Props
+
+These props allow you to control input groups (radio button-like behavior) and receive notifications when the selection changes.
+
+${A.join(`
+
+`)}` : "", _ = [];
+  g.forEach((a) => {
+    const b = M(a.formName), D = `on${b[0].toUpperCase()}${b.slice(
+      1
+    )}Submit`, s = `${b[0].toUpperCase()}${b.slice(
+      1
+    )}FormData`, E = a.inputs.map((t) => {
+      const u = t.propName, P = J(t.type, t.name);
+      return `- \`${u}\` (${P}) - ${t.name}`;
+    }).join(`
+`);
+    _.push(`### \`${D}\` ((formData: ${s}) => void, optional)
+
+Callback fired when the "${a.formName}" form is submitted. Called with a typed object containing all form input values with human-readable property names.
+
+**Form data shape:**
+\`\`\`typescript
+interface ${s} {
+${a.inputs.map((t) => {
+      const u = t.propName, P = J(t.type, t.name);
+      return `  ${u}: ${P};`;
+    }).join(`
+`)}
+}
+\`\`\`
+
+**Form inputs:**
+${E}`);
+  });
+  const S = _.length > 0 ? `## Form Submission Props
+
+These props allow you to handle form submissions and access form input values.
+
+${_.join(`
+
+`)}` : "";
+  c.forEach((a) => {
+    const b = a.propName, s = `on${b[0].toUpperCase() + b.slice(1)}Change`, E = `${b}Options`;
+    r.push(`### \`${b}\` (string, optional)
+
+Controls the selected value of the "${a.name}" dropdown (Component ID: ${a.id}).
+
+When provided, the select input operates in controlled mode - the parent component controls the current value.
+
+### \`${E}\` (Array<string | { value: string; label: string }>, optional)
+
+Sets the available options for the "${a.name}" dropdown. Can be an array of strings (used as both value and label) or an array of objects with \`value\` and \`label\` properties.
+
+**Example:**
+\`\`\`tsx
+// Simple string array
+${E}={["Option 1", "Option 2", "Option 3"]}
+
+// Object array with separate values and labels
+${E}={[
+  { value: "opt1", label: "Option 1" },
+  { value: "opt2", label: "Option 2" },
+]}
+\`\`\`
+
+### \`${s}\` ((value: string) => void, optional)
+
+Callback fired when the user selects a different option in the "${a.name}" dropdown. Called with the selected value.`);
+  });
+  const v = r.length > 0 ? `## Select Input Props
+
+These props allow you to control select/dropdown inputs and respond to value changes.
+
+${r.join(`
+
+`)}` : "";
+  y.forEach((a) => {
+    const b = a.propName, s = `on${b[0].toUpperCase() + b.slice(1)}Click`;
+    C.push(`### \`${s}\` (() => void, optional)
+
+Callback fired when the "${a.name}" button is clicked (Component ID: ${a.id}).
+
+Action type: \`${a.actionType}\``);
+  });
+  const U = C.length > 0 ? `## Action Button Props
+
+These props allow you to respond to button clicks and other user interactions.
+
+${C.join(`
+
+`)}` : "", j = `## Props
+
+### Data Props
+
+${f}
+
+${$}
+
+${x}
+
+${S}
+
+${v}
+
+${U}`, w = p.length > 0 && p[0].arrayContainer ? `<${e}
+  ${p.map(
+    (a) => a.arrayContainer ? `${a.arrayContainer.propName}={[
+    {
+      ${a.arrayContainer?.components.map(
+      (b) => `${b.propName}: "${b.type === "component:image" ? "https://example.com/image.jpg" : "Example value"}"`
+    ).join(`,
+      `)}
+    }
+  ]}` : ""
+  ).filter(Boolean).join(`
+  `)}
+/>` : `<${e} />`;
+  let T = "";
+  if (p.length > 0 && p[0]) {
+    const a = p[0], b = M(a.name || "container"), D = `${b[0].toUpperCase()}${b.slice(
+      1
+    )}IndexChange`;
+    T = `## Controlling Slides
+
+You can imperatively control which slide is displayed and listen for slide changes:
+
+\`\`\`tsx
+import { useState } from "react";
+import { ${e} } from "./${e}";
+
+function MyComponent() {
+  const [currentSlide, setCurrentSlide] = useState(0);
+
+  return (
+    <>
+      <button onClick={() => setCurrentSlide((prev) => Math.max(0, prev - 1))}>
+        Previous
+      </button>
+      <button onClick={() => setCurrentSlide((prev) => prev + 1)}>
+        Next
+      </button>
+      <${e}
+        ${p.map(
+      (s) => s.arrayContainer ? `${s.arrayContainer.propName}={[/* array of items */]}` : ""
+    ).filter(Boolean).join(`
+        `)}
+        ${b}CurrentIndex={currentSlide}
+        on${D}={(index) => setCurrentSlide(index)}
+      />
+    </>
+  );
+}
+\`\`\``;
+  }
+  return `# ${e}
+
+Encore App Wrapper Component
+
+This component wraps the Encore Studio app **"${o}"** (App ID: \`${h}\`) for the page **"${d}"** (Page ID: \`${l}\`).
+
+The component automatically maps props to data-bound components within the app. Components marked with \`encore:data\` tags are exposed as props, allowing you to dynamically populate content.
+
+${j}
+
+## Usage
+
+\`\`\`tsx
+import { ${e} } from "./${e}";
+
+function MyComponent() {
+  return (
+    <${e}
+      ${p.map(
+    (a) => a.arrayContainer ? `${a.arrayContainer.propName}={[/* array of items */]}` : ""
+  ).filter(Boolean).join(`
+      `)}
+    />
+  );
+}
+\`\`\`
+
+## Example
+
+\`\`\`tsx
+${w}
+\`\`\`
+
+${T}
+`;
+}
+function $e(h, l) {
+  const o = M(h), d = M(l), e = o.charAt(0).toUpperCase() + o.slice(1), p = d.charAt(0).toUpperCase() + d.slice(1);
+  return {
+    directoryPath: k(e, p),
+    componentName: p
+  };
+}
+async function Pe(h) {
+  const l = `${G}/devices/apps/${h}`;
+  console.log(`Fetching app data from ${l}...`);
+  try {
+    const o = await V(l), d = JSON.parse(o);
+    return { pages: d?.app?.data?.pages || [], appData: d };
+  } catch (o) {
+    throw console.error("Failed to fetch app data:", o), o;
+  }
+}
+async function Z({
+  appId: h,
+  pageId: l,
+  outputPath: o,
+  cachedAppData: d,
+  isProduction: e
+}) {
+  console.log(`Generating wrapper for app: ${h}, page: ${l}`);
+  let p = o, n = !1;
+  const i = o.split(".").pop()?.toLowerCase();
+  if (i !== "tsx" && i !== "ts" && i !== "jsx" && i !== "js") {
+    const { stat: s } = await import("fs/promises");
+    try {
+      (await s(o)).isDirectory() && (n = !0);
+    } catch {
+      (!i || o.endsWith("/")) && (n = !0);
+    }
+  }
+  n && console.log(
+    "Output path is a directory, will generate filename from app/page names"
+  ), console.log(`Output path: ${o}`);
+  const g = k(process.cwd(), ".temp-bravo", h, l);
+  B(g) || await H(g, { recursive: !0 });
+  const c = [
+    {
+      url: `${G}/devices/apps/${h}`,
+      filename: "app.json",
+      skipIfCached: !0
+    },
+    {
+      url: `${G}/devices/apps/${h}/node/${l}`,
+      filename: "page.json"
+    },
+    {
+      url: `${se}/${h}/draft/components/${l}.js`,
+      filename: "component.js"
+    }
+  ];
+  for (const s of c) {
+    if (s.skipIfCached && d) {
+      console.log(`Using cached ${s.filename} (skipping download)`);
+      const E = k(g, s.filename);
+      await q(
+        E,
+        JSON.stringify(d, null, 2),
+        "utf-8"
+      ), console.log(`✓ Saved ${s.filename} from cache`);
+      continue;
+    }
+    try {
+      console.log(`Downloading ${s.filename} from ${s.url}...`);
+      const E = await V(s.url, s.headers), t = k(g, s.filename);
+      await q(t, E, "utf-8"), console.log(`✓ Saved ${s.filename}`);
+    } catch (E) {
+      throw console.error(`✗ Failed to download ${s.filename}:`, E), E;
+    }
+  }
+  const y = k(g, "page.json"), m = await R(y, "utf-8"), N = JSON.parse(m);
+  let r = N.data || N;
+  if (console.log("Page response keys:", Object.keys(N)), N.data && console.log("Page data keys:", Object.keys(N.data)), console.log("Has body?", !!r.body), console.log("Has data.body?", !!r.data?.body), !r.body && !r.data?.body) {
+    console.log("Page data doesn't have body, trying app.json...");
+    try {
+      let s = d;
+      if (s)
+        console.log("Using cached app.json data");
+      else {
+        const u = `${G}/devices/apps/${h}`, P = await V(u);
+        s = JSON.parse(P);
+      }
+      console.log("App data keys:", Object.keys(s)), console.log(
+        "App.app keys:",
+        s?.app ? Object.keys(s.app) : "N/A"
+      ), console.log(
+        "App.app.data keys:",
+        s?.app?.data ? Object.keys(s.app.data) : "N/A"
+      );
+      const E = s?.app?.data?.pages || [];
+      console.log(`Found ${E.length} pages in app.json`), E.length > 0 && console.log("First page ID:", E[0]?.id);
+      const t = E.find((u) => u.id === l);
+      if (t)
+        r = t, console.log("✓ Found page data in app.json"), console.log("Page from app.json has body?", !!r.body), console.log(
+          "Page body length:",
+          Array.isArray(r.body) ? r.body.length : "N/A"
+        );
+      else {
+        console.warn(`Page ${l} not found in app.json`), console.warn(
+          "Available page IDs:",
+          E.map((P) => P.id)
+        );
+        const u = k(
+          process.cwd(),
+          "saved-apps",
+          h,
+          `page-${l}.json`
+        );
+        if (B(u)) {
+          console.log("Trying saved-apps page file...");
+          try {
+            const P = await R(u, "utf-8"), I = JSON.parse(P), F = I.data || I;
+            F.body && (r = F, console.log("✓ Found page data in saved-apps"), console.log(
+              "Page body length:",
+              Array.isArray(r.body) ? r.body.length : "N/A"
+            ));
+          } catch (P) {
+            console.warn("Could not load saved-apps page:", P);
+          }
+        }
+      }
+    } catch (s) {
+      console.warn("Could not load app.json:", s);
+      const E = k(
+        process.cwd(),
+        "saved-apps",
+        h,
+        `page-${l}.json`
+      );
+      if (B(E)) {
+        console.log("Trying saved-apps page file...");
+        try {
+          const t = await R(E, "utf-8"), u = JSON.parse(t), P = u.data || u;
+          P.body && (r = P, console.log("✓ Found page data in saved-apps"), console.log(
+            "Page body length:",
+            Array.isArray(r.body) ? r.body.length : "N/A"
+          ));
+        } catch (t) {
+          console.warn("Could not load saved-apps page:", t);
+        }
+      }
+    }
+  }
+  const C = ie(r), f = pe(r);
+  let $ = "Encore App", A = "Page";
+  try {
+    let s = d;
+    if (!s) {
+      const E = k(g, "app.json");
+      if (B(E)) {
+        const t = await R(E, "utf-8");
+        s = JSON.parse(t);
+      }
+    }
+    s && ($ = s?.app?.store?.name || $, console.log(`App name: ${$}`));
+  } catch {
+  }
+  A = r.name || r.id || A, console.log(`Page name: ${A}`), console.log(`
+Found ${C.length} slider(s):`), C.forEach((s, E) => {
+    console.log(`
+  Slider ${E + 1}:`), console.log(`    ID: ${s.id}`), console.log(`    Name: ${s.name}`), s.arrayContainer ? (console.log(
+      `    Array Container: ${s.arrayContainer.name} (${s.arrayContainer.id})`
+    ), console.log("    Components:"), s.arrayContainer.components.forEach((t) => {
+      console.log(
+        `      - ${t.name} (${t.id}): ${t.type} -> prop: ${t.propName}: ${t.propType}`
+      );
+    })) : console.log("    No array container found");
+  }), console.log(
+    `
+Found ${f.length} standalone component(s):`
+  ), f.forEach((s) => {
+    console.log(
+      `  - ${s.name} (${s.id}): ${s.type} -> prop: ${s.propName}: ${s.propType}`
+    );
+  });
+  const x = ce(r);
+  console.log(`
+Found ${x.length} input group(s):`), x.forEach((s, E) => {
+    console.log(`
+  Input Group ${E + 1}:`), console.log(`    Name: ${s.groupName}`), console.log(`    Type: ${s.groupType}`), console.log("    Elements:"), s.elements.forEach((t) => {
+      console.log(`      - ${t.name} (${t.id})`);
+    });
+  });
+  const _ = le(r);
+  de(_), console.log(`
+Found ${_.length} form(s):`), _.forEach((s, E) => {
+    console.log(`
+  Form ${E + 1}:`), console.log(`    Name: ${s.formName}`), console.log(`    ID: ${s.formId}`), s.submitButtonId && console.log(`    Submit Button ID: ${s.submitButtonId}`), console.log("    Inputs:"), s.inputs.forEach((t) => {
+      console.log(`      - ${t.name} (${t.id}): ${t.type}`);
+    });
+  });
+  const S = he(r, _);
+  console.log(`
+Found ${S.length} standalone select input(s):`), S.forEach((s) => {
+    console.log(
+      `  - ${s.name} (${s.id}) -> prop: ${s.propName}, on${s.propName[0].toUpperCase()}${s.propName.slice(1)}Change`
+    );
+  });
+  const v = fe(r);
+  console.log(`
+Found ${v.length} action button(s):`), v.forEach((s) => {
+    console.log(
+      `  - ${s.name} (${s.id}) -> on${s.propName[0].toUpperCase()}${s.propName.slice(
+        1
+      )}Click (action: ${s.actionType})`
+    );
+  }), C.length === 0 && f.length === 0 && x.length === 0 && _.length === 0 && S.length === 0 && v.length === 0 && console.warn(
+    `
+⚠ No sliders, standalone components, input groups, forms, select inputs, or action buttons found. Generating empty wrapper.`
+  );
+  const { directoryPath: U, componentName: j } = $e($, A), w = U;
+  if (n)
+    p = k(o, w);
+  else {
+    const s = ae(p);
+    p = k(s, w);
+  }
+  console.log(`Component directory: ${w}`);
+  const T = ge(
+    h,
+    l,
+    j,
+    C,
+    f,
+    x,
+    _,
+    S,
+    v,
+    !!e
+  ), a = ye(
+    h,
+    l,
+    $,
+    A,
+    j,
+    C,
+    f,
+    x,
+    _,
+    S,
+    v
+  );
+  if (B(p) || await H(p, { recursive: !0 }), e) {
+    const s = k(g, "component.js");
+    let E = "";
+    try {
+      E = await R(s, "utf-8");
+    } catch (P) {
+      console.warn("Could not read component.js for production build", P);
+    }
+    let t = d;
+    if (!t)
+      try {
+        const P = k(g, "app.json"), I = await R(P, "utf-8");
+        t = JSON.parse(I);
+      } catch (P) {
+        console.warn("Could not read app.json for production build", P);
+      }
+    const u = {
+      app: t,
+      page: r,
+      componentCode: E
+    };
+    await q(k(p, "data.json"), JSON.stringify(u, null, 2), "utf-8"), console.log("✓ Generated data.json for production mode");
+  }
+  const b = k(p, "index.tsx"), D = k(p, "README.md");
+  await q(b, T, "utf-8"), await q(D, a, "utf-8"), console.log(`
+✓ Generated wrapper component at: ${b}`), console.log(`✓ Generated documentation at: ${D}`);
+}
+function X() {
+  console.log(`
+Usage: generate-wrapper.ts <appId> [pageId] <outputPath>
+
+Arguments:
+  appId      The Encore app ID
+  pageId     The Encore page ID (optional - if omitted, generates wrappers for ALL pages)
+  outputPath Path where the generated TSX file(s) should be saved
+
+Environment variables:
+  APPS_SERVICE_URL  Base URL for the apps service (default: http://localhost:3000)
+
+Example:
+  generate-wrapper.ts 01KA964B1T6KCKSKCNMYSTKRKZ 01KA964B2F42MN4WGCYDTG1Y70 ./src/components/MyEncoreApp.tsx
+  generate-wrapper.ts 01KA964B1T6KCKSKCNMYSTKRKZ ./src/components/  (Generates all pages)
+`);
+}
+async function ve(h) {
+  const l = h.includes("--production"), o = h.filter((n) => n !== "--production");
+  if ((o.length < 2 || o.includes("--help") || o.includes("-h")) && (X(), process.exit(o.includes("--help") || o.includes("-h") ? 0 : 1)), o.length === 2) {
+    const [n, i] = o;
+    try {
+      const { pages: g, appData: c } = await Pe(n);
+      if (console.log(`Found ${g.length} pages.`), g.length === 0) {
+        console.warn("No pages found for this app.");
+        return;
+      }
+      console.log(
+        `Caching app.json data for reuse across ${g.length} page(s)...`
+      );
+      for (const y of g)
+        if (y.id) {
+          console.log(`
+----------------------------------------`), console.log(`Processing page: ${y.name || "Unnamed"} (${y.id})`), console.log("----------------------------------------");
+          try {
+            await Z({
+              appId: n,
+              pageId: y.id,
+              outputPath: i,
+              cachedAppData: c,
+              isProduction: l
+            });
+          } catch (m) {
+            console.warn("Error with page:", m instanceof Error ? m.message : m);
+          }
+        }
+    } catch (g) {
+      console.error(`
+Error:`, g instanceof Error ? g.message : g), process.exit(1);
+    }
+    return;
+  }
+  const [d, e, p] = o;
+  (!d || !e || !p) && (console.error("Error: Missing required arguments"), X(), process.exit(1));
+  try {
+    await Z({ appId: d, pageId: e, outputPath: p, isProduction: l });
+  } catch (n) {
+    console.error(`
+Error:`, n instanceof Error ? n.message : n), process.exit(1);
+  }
+}
+export {
+  ve as runGenerate
+};
+//# sourceMappingURL=generate.js.map