@junojs/core 0.1.0

package/dist/index.js

@@ -0,0 +1,896 @@
+var C = Object.defineProperty;
+var k = (i, t, e) => t in i ? C(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var h = (i, t, e) => k(i, typeof t != "symbol" ? t + "" : t, e);
+import "reflect-metadata";
+function J(i) {
+  return (t) => {
+    i.shadow === void 0 && (i.shadow = !0), Reflect.defineMetadata("nf:config", i, t);
+  };
+}
+function W() {
+  return (i, t) => {
+    const e = Reflect.getMetadata("nf:states", i) || [];
+    e.push(t), Reflect.defineMetadata("nf:states", e, i);
+  };
+}
+function K() {
+  return (i, t) => {
+    const e = Reflect.getMetadata("nf:inputs", i) || [];
+    e.push(t), Reflect.defineMetadata("nf:inputs", e, i);
+  };
+}
+function z(i) {
+  return (t, e) => {
+    const s = Reflect.getMetadata("nf:params", t) || [];
+    s.push({ key: e, paramName: i || e }), Reflect.defineMetadata("nf:params", s, t);
+  };
+}
+function G(i) {
+  return (t, e) => {
+    Reflect.defineMetadata("nf:inject", i, t, e);
+  };
+}
+function Q() {
+  return (i, t) => {
+    const e = Reflect.getMetadata("nf:transforms", i) || [];
+    e.push(t), Reflect.defineMetadata("nf:transforms", e, i);
+  };
+}
+function X() {
+  return (i, t) => {
+    const e = Reflect.getMetadata("nf:actions", i) || [];
+    e.push(t), Reflect.defineMetadata("nf:actions", e, i);
+  };
+}
+function B(i) {
+  return (t, e) => {
+    const s = Reflect.getMetadata("nf:provides", t) || [];
+    s.push({ key: i, property: e }), Reflect.defineMetadata("nf:provides", s, t);
+  };
+}
+function Y(i) {
+  return (t, e) => {
+    const s = Reflect.getMetadata("nf:injects", t) || [];
+    s.push({ key: i, property: e }), Reflect.defineMetadata("nf:injects", s, t);
+  };
+}
+function Z(i) {
+  return (t) => {
+    const e = Reflect.getMetadata("nf:refine", t) || [];
+    e.push(i), Reflect.defineMetadata("nf:refine", e, t);
+  };
+}
+function tt(i, t) {
+  return (e, s) => {
+    const n = Reflect.getMetadata("nf:validates", e) || [];
+    n.push({ key: s, predicate: i, message: t }), Reflect.defineMetadata("nf:validates", n, e);
+  };
+}
+function et(i) {
+  return (t, e) => {
+    Reflect.defineMetadata("nf:intercept", i, t, e);
+  };
+}
+function st(i) {
+  return (t) => {
+    Reflect.defineMetadata("nf:canActivate", i, t);
+  };
+}
+function nt() {
+  return (i, t) => {
+    const e = Reflect.getMetadata("nf:host-properties", i) || [];
+    e.push(t), Reflect.defineMetadata("nf:host-properties", e, i);
+  };
+}
+function it(i) {
+  return (t) => {
+    Reflect.defineMetadata("nf:schema", i, t);
+  };
+}
+function rt(i = "local") {
+  return (t, e) => {
+    const s = Reflect.getMetadata("nf:persist", t) || [];
+    s.push({
+      property: e,
+      storage: i,
+      key: `nf:${t.constructor.name}:${e}`
+    }), Reflect.defineMetadata("nf:persist", s, t);
+  };
+}
+function $(i) {
+  if (!(typeof window > "u"))
+    return i === "session" ? window.sessionStorage : window.localStorage;
+}
+function j(i) {
+  const t = Reflect.getMetadata("nf:persist", i) || [];
+  for (const e of t) {
+    const s = $(e.storage);
+    if (!s) continue;
+    const n = s.getItem(e.key);
+    if (n !== null)
+      try {
+        i[e.property] = JSON.parse(n);
+      } catch {
+        i[e.property] = n;
+      }
+  }
+}
+function O(i, t, e) {
+  const n = (Reflect.getMetadata("nf:persist", i) || []).find((r) => r.property === t);
+  if (n) {
+    const r = $(n.storage);
+    r && r.setItem(n.key, JSON.stringify(e));
+  }
+}
+function q(i, t) {
+  const e = Reflect.getMetadata("nf:states", i) || [], s = Reflect.getMetadata("nf:inputs", i) || [], n = [...e, ...s, "errors"];
+  let r;
+  return r = new Proxy(i, {
+    set(o, a, c) {
+      const l = o[a];
+      return o[a] = c, n.includes(a) && l !== c && (O(o, a, c), t()), !0;
+    },
+    get(o, a) {
+      const c = o[a];
+      return typeof c == "function" ? c.bind(r) : c;
+    }
+  }), r;
+}
+class D {
+  static render(t, e) {
+    const r = new DOMParser().parseFromString(`<div>${t}</div>`, "text/html").body.firstElementChild;
+    return r ? (this.processNode(r, e), r) : document.createElement("div");
+  }
+  static processNode(t, e) {
+    var c, l, f, p;
+    if (t.nodeType === Node.TEXT_NODE) {
+      t.textContent = this.interpolate(t.textContent || "", e);
+      return;
+    }
+    if (t.nodeType !== Node.ELEMENT_NODE) return;
+    const s = t, n = s.tagName.toLowerCase();
+    if (n === "for") {
+      const m = (((c = s.getAttribute("each")) == null ? void 0 : c.trim()) || "").replace(/^\{/, "").replace(/\}$/, "").match(/(\w+)\s+in\s+(.+)/);
+      if (m) {
+        const g = m[1], y = m[2], v = this.evaluateExpression(y, e), A = document.createDocumentFragment();
+        Array.isArray(v) && v.forEach((E) => {
+          const w = Object.create(e);
+          w[g] = E;
+          const P = s.cloneNode(!0);
+          for (Array.from(P.childNodes).forEach((I) => this.processNode(I, w)); P.firstChild; )
+            A.appendChild(P.firstChild);
+        }), (l = s.parentNode) == null || l.replaceChild(A, s);
+      }
+      return;
+    }
+    if (n === "if") {
+      const d = (((f = s.getAttribute("condition")) == null ? void 0 : f.trim()) || "").replace(/^\{/, "").replace(/\}$/, "");
+      let m = !1;
+      try {
+        m = !!new Function("ctx", `with(ctx) { return ${d} }`)(e);
+      } catch (E) {
+        console.error(`JunoEngine condition error: ${d}`, E);
+      }
+      const g = document.createDocumentFragment(), y = Array.from(s.childNodes), v = y.findIndex((E) => {
+        var w;
+        return ((w = E.tagName) == null ? void 0 : w.toLowerCase()) === "else";
+      });
+      (m ? v !== -1 ? y.slice(0, v) : y : v !== -1 ? Array.from(y[v].childNodes) : []).forEach((E) => {
+        const w = E.cloneNode(!0);
+        this.processNode(w, e), g.appendChild(w);
+      }), (p = s.parentNode) == null || p.replaceChild(g, s);
+      return;
+    }
+    const r = Array.from(s.attributes), o = n.includes("-");
+    r.forEach((u) => {
+      const d = /^\{[^{}]+\}$/.test(u.value);
+      if (o && d) {
+        const m = u.value.slice(1, -1), g = this.evaluateExpression(m, e), y = u.name.replace(/-([a-z])/g, (v) => v[1].toUpperCase());
+        s[y] = g;
+      } else {
+        const m = this.interpolate(u.value, e);
+        m !== u.value && s.setAttribute(u.name, m);
+      }
+    }), Array.from(s.childNodes).forEach((u) => this.processNode(u, e));
+  }
+  static evaluateExpression(t, e) {
+    const s = t.trim().split("|").map((c) => c.trim()), n = s[0], r = s[1], o = e.__transforms__ || {};
+    let a;
+    try {
+      /^[\w.]+$/.test(n) ? a = n.split(".").reduce((c, l) => c == null ? void 0 : c[l], e) : a = new Function("ctx", `with(ctx) { return ${n} }`)(e);
+    } catch {
+      return;
+    }
+    return r && o[r] && (a = o[r](a)), a;
+  }
+  static interpolate(t, e) {
+    return t.replace(/\{((?:[^{}]|\{[^{}]*\})*)\}/g, (s, n) => {
+      const r = this.evaluateExpression(n, e);
+      return r !== void 0 ? String(r) : "";
+    });
+  }
+}
+function U(i, t) {
+  let e;
+  typeof t == "string" ? e = new DOMParser().parseFromString(`<body>${t}</body>`, "text/html").body : e = t;
+  const s = i instanceof ShadowRoot ? i : document, n = s.activeElement, r = n && n.id ? `#${n.id}` : null, o = n ? n.selectionStart : null, a = n ? n.selectionEnd : null;
+  if (L(i, e, i), r) {
+    const c = i.querySelector(r);
+    c && c !== s.activeElement && (c.focus(), o !== null && a !== null && c.setSelectionRange(o, a));
+  }
+}
+function L(i, t, e) {
+  const s = Array.from(i.childNodes), n = Array.from(t.childNodes), r = Math.max(s.length, n.length);
+  for (let o = 0; o < r; o++) {
+    const a = s[o], c = n[o];
+    if (!a) {
+      i.appendChild(c);
+      continue;
+    }
+    if (!c) {
+      i.removeChild(a);
+      continue;
+    }
+    if (a.nodeType !== c.nodeType || a.tagName !== c.tagName) {
+      i.replaceChild(c, a);
+      continue;
+    }
+    if (a.nodeType === Node.TEXT_NODE) {
+      a.textContent !== c.textContent && (a.textContent = c.textContent);
+      continue;
+    }
+    if (a.nodeType === Node.ELEMENT_NODE) {
+      const l = a, f = c, p = l.getAttributeNames(), u = f.getAttributeNames();
+      for (const d of p)
+        f.hasAttribute(d) || l.removeAttribute(d);
+      for (const d of u) {
+        const m = f.getAttribute(d);
+        l.getAttribute(d) !== m && l.setAttribute(d, m);
+        const g = d.replace(/-([a-z])/g, (y) => y[1].toUpperCase());
+        l.tagName.includes("-") && f[g] !== void 0 && (l[g] = f[g]);
+      }
+      if (l instanceof HTMLInputElement || l instanceof HTMLTextAreaElement) {
+        const d = f.value || f.getAttribute("value") || "";
+        l.value !== d && (l.value = d);
+      }
+      (!l.tagName.includes("-") || l === e) && L(l, f, e);
+    }
+  }
+}
+const x = class x {
+  constructor() {
+    h(this, "routes", []);
+    h(this, "listeners", []);
+    h(this, "lastTab", null);
+    h(this, "lastParams", {});
+    typeof window < "u" && (window.addEventListener("popstate", () => this.handleLocationChange()), window.addEventListener("hashchange", () => this.handleLocationChange()));
+  }
+  static get instance() {
+    return x._instance || (x._instance = new x()), x._instance;
+  }
+  /**
+   * Register available routes.
+   */
+  register(t) {
+    this.routes = t;
+  }
+  /**
+   * Programmatically navigate to a path.
+   */
+  navigate(t, e = !0) {
+    if (typeof window > "u") return;
+    const s = t.startsWith("/") ? t : `/${t}`;
+    window.location.pathname !== s && (window.history.pushState({}, "", s), e && this.handleLocationChange());
+  }
+  /**
+   * Subscribe to route changes.
+   */
+  onRouteMatch(t) {
+    return this.listeners.push(t), this.lastTab !== null ? t(this.lastTab, this.lastParams) : this.handleLocationChange(), () => {
+      this.listeners = this.listeners.filter((e) => e !== t);
+    };
+  }
+  /**
+   * Manually trigger initial route matching (e.g. on page load).
+   */
+  init() {
+    this.handleLocationChange();
+  }
+  async handleLocationChange() {
+    if (typeof window > "u") return;
+    const t = window.location.pathname;
+    let e, s = {};
+    for (const n of this.routes) {
+      if (n.path === t || `/${n.tab}` === t) {
+        e = n;
+        break;
+      }
+      if (n.path.includes("/:")) {
+        const r = n.path.split("/"), o = t.split("/");
+        if (r.length === o.length) {
+          let a = !0;
+          const c = {};
+          for (let l = 0; l < r.length; l++)
+            if (r[l].startsWith(":"))
+              c[r[l].substring(1)] = o[l];
+            else if (r[l] !== o[l]) {
+              a = !1;
+              break;
+            }
+          if (a) {
+            e = n, s = c;
+            break;
+          }
+        }
+      }
+    }
+    if (e) {
+      if (e.canActivate)
+        try {
+          const n = await e.canActivate();
+          if (n === !1)
+            return;
+          if (typeof n == "string") {
+            this.navigate(n);
+            return;
+          }
+        } catch (n) {
+          console.error(`Route guard error on ${e.path}:`, n);
+          return;
+        }
+      e.title && (document.title = e.title), this.notify(e.tab, s);
+    } else if (t === "/" || t === "") {
+      const n = this.routes[0];
+      n && this.notify(n.tab, {});
+    }
+  }
+  notify(t, e) {
+    this.lastTab = t, this.lastParams = e, this.listeners.forEach((s) => s(t, e));
+  }
+  /**
+   * Get the current path.
+   */
+  get currentPath() {
+    return typeof window < "u" ? window.location.pathname : "/";
+  }
+};
+h(x, "_instance");
+let N = x;
+async function at(i) {
+  const t = Reflect.getMetadata("nf:config", i);
+  if (!t || !t.tag)
+    throw new Error("Missing @Component decorator or tag!");
+  customElements.define(
+    t.tag,
+    class extends HTMLElement {
+      constructor() {
+        super();
+        h(this, "instance");
+        h(this, "proxy");
+        h(this, "target");
+        h(this, "routeUnsubscribe");
+        this.instance = new i(), (Reflect.getMetadata("nf:host-properties", i.prototype) || []).forEach((r) => {
+          this.instance[r] = this;
+        }), (Reflect.getMetadata("nf:inputs", i.prototype) || []).forEach((r) => {
+          let o = this.hasOwnProperty(r) ? this[r] : void 0;
+          Object.defineProperty(this, r, {
+            get: () => this.proxy[r],
+            set: (a) => {
+              this.proxy[r] = a, this.update();
+            }
+          }), o !== void 0 && (this.instance[r] = o);
+        }), this.instance.errors || (this.instance.errors = {}), this.instance.isValid || (this.instance.isValid = () => {
+          this.proxy.errors = {};
+          let r = !0;
+          const o = Reflect.getMetadata("nf:schema", i), a = Reflect.getMetadata("nf:refine", i) || [], c = Reflect.getMetadata("nf:validates", i.prototype) || [], l = [];
+          if (o && typeof o.parse == "function") {
+            const f = o.parse(this.proxy);
+            f instanceof Promise ? l.push(f.then((p) => {
+              p.success || (r = !1, this.proxy.errors = { ...this.proxy.errors, ...p.errors });
+            })) : f.success || (r = !1, this.proxy.errors = { ...this.proxy.errors, ...f.errors });
+          }
+          for (const f of c) {
+            const p = this.proxy[f.key], u = f.predicate(p);
+            u instanceof Promise ? l.push(
+              u.then((d) => {
+                d || (r = !1, this.proxy.errors = { ...this.proxy.errors, [f.key]: f.message });
+              })
+            ) : u || (r = !1, this.proxy.errors = { ...this.proxy.errors, [f.key]: f.message });
+          }
+          for (const f of a) {
+            const p = f.validate(this.proxy);
+            if (p instanceof Promise)
+              l.push(
+                p.then((u) => {
+                  if (!u) {
+                    r = !1;
+                    const d = f.fields[f.fields.length - 1];
+                    this.proxy.errors = { ...this.proxy.errors, [d]: f.message };
+                  }
+                })
+              );
+            else if (!p) {
+              r = !1;
+              const u = f.fields[f.fields.length - 1];
+              this.proxy.errors = { ...this.proxy.errors, [u]: f.message };
+            }
+          }
+          return l.length > 0 ? Promise.all(l).then(() => r) : r;
+        }), j(this.instance), this.proxy = q(this.instance, () => this.update()), t.shadow ? this.target = this.shadowRoot || this.attachShadow({ mode: "open" }) : this.target = this;
+        const n = (r, o) => {
+          let a = r.target;
+          for (; a && a !== this.parentElement; ) {
+            const c = a.getAttribute(o);
+            if (c) {
+              const l = c.match(/^(\w+)(?:\((.*)\))?$/);
+              if (l) {
+                const [f, p, u] = l, d = this.proxy[p];
+                if (typeof d == "function") {
+                  const m = Reflect.getMetadata("nf:intercept", this.instance, p);
+                  if (m) {
+                    const g = m(this.proxy);
+                    if (g instanceof Promise) {
+                      g.then((y) => {
+                        y === !1 ? (r.stopImmediatePropagation(), r.stopPropagation()) : this.executeMethod(d, r, u);
+                      });
+                      return;
+                    } else if (g === !1) {
+                      r.stopImmediatePropagation(), r.stopPropagation();
+                      return;
+                    }
+                  }
+                  this.executeMethod(d, r, u);
+                  return;
+                }
+              }
+            }
+            if (a === this) break;
+            a = a.parentElement;
+          }
+        };
+        this.target.addEventListener("click", (r) => n(r, "@click")), this.target.addEventListener("input", (r) => n(r, "@input"));
+      }
+      static get observedAttributes() {
+        return Reflect.getMetadata("nf:inputs", i.prototype) || [];
+      }
+      attributeChangedCallback(s, n, r) {
+        r && /^\{[^{}]+\}$/.test(r) || n !== r && (this.proxy ? (this.proxy[s] = r, this.update()) : this.instance && (this.instance[s] = r));
+      }
+      executeMethod(s, n, r) {
+        if (r !== void 0) {
+          const o = r.split(",").map((a) => (a = a.trim(), a === "e" || a === "$event" ? n : a === "true" ? !0 : a === "false" ? !1 : !isNaN(Number(a)) && a !== "" ? Number(a) : a.startsWith("'") && a.endsWith("'") || a.startsWith('"') && a.endsWith('"') ? a.slice(1, -1) : a));
+          s.apply(this.proxy, o);
+        } else
+          s.call(this.proxy, n);
+      }
+      async connectedCallback() {
+        const s = Reflect.getMetadata("nf:canActivate", i);
+        if (s)
+          try {
+            const o = await s();
+            if (o === !1) return;
+            if (typeof o == "string") {
+              N.instance.navigate(o);
+              return;
+            }
+          } catch (o) {
+            console.error("Guard evaluation failed:", o);
+            return;
+          }
+        if (this.instance.canActivate)
+          try {
+            const o = await this.instance.canActivate.call(this.proxy);
+            if (o === !1) return;
+            if (typeof o == "string") {
+              N.instance.navigate(o);
+              return;
+            }
+          } catch (o) {
+            console.error("Lifecycle canActivate hook failed:", o);
+            return;
+          }
+        if (t.templateUrl) {
+          const o = await fetch(t.templateUrl);
+          this.instance.template = await o.text();
+        }
+        const n = Reflect.getMetadata("nf:params", i.prototype) || [];
+        if (n.length > 0) {
+          const o = N.instance;
+          this.routeUnsubscribe = o.onRouteMatch((a, c) => {
+            n.forEach((l) => {
+              c[l.paramName] !== void 0 && this.proxy[l.key] !== c[l.paramName] && (this.proxy[l.key] = c[l.paramName]);
+            });
+          });
+        }
+        (Reflect.getMetadata("nf:injects", i.prototype) || []).forEach((o) => {
+          let a = this.parentElement;
+          for (; a; ) {
+            if (a.instance) {
+              const l = (Reflect.getMetadata("nf:provides", a.instance.constructor) || []).find((f) => f.key === o.key);
+              if (l) {
+                this.proxy[o.property] = a.proxy[l.property];
+                break;
+              }
+            }
+            a = a.parentElement || a.getRootNode().host;
+          }
+        }), this.instance.onInit && await this.instance.onInit.call(this.proxy), this.update(), this.instance.onRender && this.instance.onRender.call(this.proxy, this);
+      }
+      disconnectedCallback() {
+        this.routeUnsubscribe && this.routeUnsubscribe(), this.instance.onDestroy && this.instance.onDestroy();
+      }
+      update() {
+        const s = this.instance.template || "<div>No template</div>", n = Reflect.getMetadata("nf:transforms", this.instance) || [], r = {};
+        for (const c of n)
+          typeof this.proxy[c] == "function" && (r[c] = this.proxy[c]);
+        const o = Object.create(this.proxy);
+        o.__transforms__ = r;
+        const a = D.render(s, o);
+        U(this.target, a);
+      }
+    }
+  );
+}
+const M = class M {
+  constructor() {
+    // ── State ─────────────────────────────────────────────────
+    h(this, "middlewares", []);
+  }
+  static get instance() {
+    return M._instance || (M._instance = new M()), M._instance;
+  }
+  // ── Public API ────────────────────────────────────────────
+  /** Register an error-handling middleware. Returns an unsubscribe function. */
+  addMiddleware(t) {
+    return this.middlewares.push(t), () => {
+      this.middlewares = this.middlewares.filter((e) => e !== t);
+    };
+  }
+  /**
+   * Run the middleware chain. The first middleware that returns `true`
+   * stops propagation. If no middleware handles it, logs to console.
+   */
+  handle(t) {
+    for (const e of this.middlewares)
+      if (e(t) === !0) return;
+    console.error("[JunoJS ErrorHandler] Unhandled error:", t.message, t);
+  }
+  /** Convenience: create a JunoJSError from an HTTP Response. */
+  static fromResponse(t, e) {
+    return {
+      status: t.status,
+      message: `HTTP ${t.status}: ${t.statusText}`,
+      url: e,
+      original: t
+    };
+  }
+  /** Convenience: create a JunoJSError from a caught exception. */
+  static fromException(t) {
+    return t instanceof Error ? { message: t.message, original: t } : { message: String(t), original: t };
+  }
+};
+// ── Singleton ─────────────────────────────────────────────
+h(M, "_instance");
+let S = M;
+class ot {
+  constructor() {
+    h(this, "_initialValues", {});
+    h(this, "_touched", {});
+    queueMicrotask(() => this._captureInitialValues());
+  }
+  // ─── Public API ───────────────────────────────────────────
+  /** Returns true if every validated field passes all its rules. */
+  isValid() {
+    const t = this.getErrors();
+    return Object.keys(t).length === 0;
+  }
+  /** Returns a map of field → error messages (only fields with errors). */
+  getErrors() {
+    const t = Reflect.getMetadata("nf:validators", this) || /* @__PURE__ */ new Map(), e = {};
+    return t.forEach((s, n) => {
+      const r = this[n], o = [];
+      for (const a of s)
+        a.validate(r, this) || o.push(a.message);
+      o.length > 0 && (e[n] = o);
+    }), e;
+  }
+  /** Resets all fields to their initial values and clears touched state. */
+  reset() {
+    for (const [t, e] of Object.entries(this._initialValues))
+      this[t] = e;
+    this._touched = {};
+  }
+  /** True if any field differs from its initial value. */
+  get dirty() {
+    for (const [t, e] of Object.entries(this._initialValues))
+      if (this[t] !== e) return !0;
+    return !1;
+  }
+  /** Per-field touched tracking. */
+  get touched() {
+    return { ...this._touched };
+  }
+  /** Mark a field as touched (e.g. on blur). */
+  markTouched(t) {
+    this._touched[t] = !0;
+  }
+  // ─── Internals ────────────────────────────────────────────
+  _captureInitialValues() {
+    (Reflect.getMetadata("nf:validators", this) || /* @__PURE__ */ new Map()).forEach((e, s) => {
+      this._initialValues[s] = this[s];
+    });
+  }
+}
+function T(i, t, e) {
+  const s = Reflect.getMetadata("nf:validators", i) || /* @__PURE__ */ new Map(), n = s.get(t) || [];
+  n.push(e), s.set(t, n), Reflect.defineMetadata("nf:validators", s, i);
+}
+function ct(i = "This field is required") {
+  return (t, e) => {
+    T(t, e, {
+      name: "required",
+      message: i,
+      validate: (s) => s != null && String(s).trim().length > 0
+    });
+  };
+}
+function lt(i = "Invalid email address") {
+  return (t, e) => {
+    T(t, e, {
+      name: "email",
+      message: i,
+      validate: (s) => s ? /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(s)) : !0
+    });
+  };
+}
+function ft(i, t) {
+  return (e, s) => {
+    T(e, s, {
+      name: "match",
+      message: t || `Must match ${i}`,
+      validate: (n, r) => n === r[i]
+    });
+  };
+}
+function dt(i, t = "Invalid format") {
+  return (e, s) => {
+    T(e, s, {
+      name: "pattern",
+      message: t,
+      validate: (n) => n ? i.test(String(n)) : !0
+    });
+  };
+}
+class b {
+  constructor() {
+    h(this, "rules", []);
+    h(this, "IS_REQUIRED", !1);
+  }
+  required(t = "Required") {
+    return this.IS_REQUIRED = !0, this.rules.push((e) => !e && e !== 0 && e !== !1 ? t : void 0), this;
+  }
+  email(t = "Invalid email") {
+    return this.rules.push((e) => {
+      if (e)
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(e)) ? void 0 : t;
+    }), this;
+  }
+  min(t, e) {
+    return this.rules.push((s) => {
+      if (s)
+        return String(s).length < t ? e || `Min length ${t}` : void 0;
+    }), this;
+  }
+  max(t, e) {
+    return this.rules.push((s) => {
+      if (s)
+        return String(s).length > t ? e || `Max length ${t}` : void 0;
+    }), this;
+  }
+  validate(t, e) {
+    for (const s of this.rules) {
+      const n = s(t, e);
+      if (n) return n;
+    }
+  }
+}
+class V {
+  constructor() {
+    h(this, "fields", {});
+    h(this, "refines", []);
+  }
+  string() {
+    return new b();
+  }
+  number() {
+    return new b();
+  }
+  boolean() {
+    return new b();
+  }
+  shape(t) {
+    return this.fields = t, this;
+  }
+  refine(t, e) {
+    return this.refines.push({ validate: t, ...e }), this;
+  }
+  async parse(t) {
+    const e = {};
+    let s = !0;
+    for (const [n, r] of Object.entries(this.fields)) {
+      const o = r.validate(t[n], t);
+      o && (e[n] = o, s = !1);
+    }
+    for (const n of this.refines) {
+      const r = n.validate(t);
+      (r instanceof Promise ? await r : r) || (e[n.path] = n.message, s = !1);
+    }
+    return { success: s, errors: s ? void 0 : e };
+  }
+}
+const ut = {
+  string: () => new b(),
+  number: () => new b(),
+  boolean: () => new b(),
+  object: (i) => new V().shape(i)
+};
+class ht {
+  constructor() {
+    h(this, "requestInterceptors", []);
+    h(this, "responseInterceptors", []);
+    h(this, "errorHandler", null);
+  }
+  /** Plug in the global ErrorHandler for automatic error routing. */
+  setErrorHandler(t) {
+    this.errorHandler = t;
+  }
+  // ── Interceptors ──────────────────────────────────────────
+  addRequestInterceptor(t) {
+    this.requestInterceptors.push(t);
+  }
+  addResponseInterceptor(t) {
+    this.responseInterceptors.push(t);
+  }
+  // ── HTTP Methods ──────────────────────────────────────────
+  async get(t, e) {
+    return this.request("GET", t, void 0, e);
+  }
+  async post(t, e, s) {
+    return this.request("POST", t, e, s);
+  }
+  async put(t, e, s) {
+    return this.request("PUT", t, e, s);
+  }
+  async delete(t, e) {
+    return this.request("DELETE", t, void 0, e);
+  }
+  async patch(t, e, s) {
+    return this.request("PATCH", t, e, s);
+  }
+  // ── Core ──────────────────────────────────────────────────
+  async request(t, e, s, n) {
+    let r = e;
+    if (n != null && n.params) {
+      const f = new URLSearchParams(n.params).toString();
+      r += (e.includes("?") ? "&" : "?") + f;
+    }
+    const o = {
+      "Content-Type": "application/json",
+      ...(n == null ? void 0 : n.headers) || {}
+    }, a = { method: t, headers: o };
+    s !== void 0 && (a.body = JSON.stringify(s));
+    const c = new AbortController();
+    let l;
+    n != null && n.signal && n.signal.addEventListener("abort", () => c.abort()), n != null && n.timeout && n.timeout > 0 && (l = setTimeout(() => c.abort(), n.timeout)), a.signal = c.signal;
+    for (const f of this.requestInterceptors) {
+      const p = f(r, a);
+      p && ([r] = p, Object.assign(a, p[1]));
+    }
+    try {
+      let f = await fetch(r, a);
+      for (const u of this.responseInterceptors) {
+        const d = u(f);
+        d && (f = d);
+      }
+      if (!f.ok)
+        throw this.errorHandler && this.errorHandler.handle(
+          S.fromResponse(f, r)
+        ), new Error(`HTTP ${f.status}: ${f.statusText}`);
+      return (f.headers.get("content-type") || "").includes("application/json") ? await f.json() : await f.text();
+    } finally {
+      l !== void 0 && clearTimeout(l);
+    }
+  }
+}
+const R = class R {
+  constructor() {
+    // ── State ─────────────────────────────────────────────────
+    h(this, "dictionaries", /* @__PURE__ */ new Map());
+    h(this, "_locale", "en");
+    h(this, "_onLocaleChange", []);
+  }
+  static get instance() {
+    return R._instance || (R._instance = new R()), R._instance;
+  }
+  /** Current active locale. */
+  get locale() {
+    return this._locale;
+  }
+  // ── Public API ────────────────────────────────────────────
+  /** Register translations for a locale. Merges with any existing entries. */
+  addTranslations(t, e) {
+    const s = this.dictionaries.get(t) || {};
+    this.dictionaries.set(t, { ...s, ...e });
+  }
+  /** Switch the active locale. */
+  setLocale(t) {
+    this.dictionaries.has(t) || console.warn(`[i18n] No translations registered for locale "${t}".`), this._locale = t;
+    for (const e of this._onLocaleChange) e();
+  }
+  /** Subscribe to locale changes. Returns an unsubscribe function. */
+  onLocaleChange(t) {
+    return this._onLocaleChange.push(t), () => {
+      this._onLocaleChange = this._onLocaleChange.filter((e) => e !== t);
+    };
+  }
+  /**
+   * Translate a key with optional parameter interpolation.
+   * Params replace `{{paramName}}` placeholders in the translation string.
+   *
+   *   t('greeting', { name: 'Ada' })  // "Hello, Ada!"
+   */
+  t(t, e) {
+    const s = this.dictionaries.get(this._locale);
+    let n = s == null ? void 0 : s[t];
+    if (n === void 0)
+      return t;
+    if (e)
+      for (const [r, o] of Object.entries(e))
+        n = n.replace(
+          new RegExp(`\\{\\{${r}\\}\\}`, "g"),
+          String(o)
+        );
+    return n;
+  }
+  /** List all registered locales. */
+  get availableLocales() {
+    return [...this.dictionaries.keys()];
+  }
+};
+// ── Singleton ─────────────────────────────────────────────
+h(R, "_instance");
+let _ = R;
+export {
+  X as Action,
+  st as CanActivate,
+  J as Component,
+  lt as Email,
+  S as ErrorHandler,
+  ot as FormModel,
+  V as FormSchema,
+  nt as HostElement,
+  ht as HttpClient,
+  _ as I18nService,
+  Y as Inject,
+  K as Input,
+  et as Intercept,
+  D as JunoEngine,
+  ft as Match,
+  z as Param,
+  dt as Pattern,
+  rt as Persist,
+  B as Provide,
+  Z as Refine,
+  ct as Required,
+  N as RouterService,
+  it as Schema,
+  b as SchemaField,
+  W as State,
+  Q as Transform,
+  G as Use,
+  tt as Validate,
+  at as bootstrap,
+  q as createReactiveProxy,
+  ut as s
+};
+//# sourceMappingURL=index.js.map