@mittwald/react-tunnel 0.1.0-alpha.115 → 0.1.0-alpha.117

package/dist/index.js

@@ -1,57 +1,63 @@
 "use client"
 /* */
-var m = Object.defineProperty;
-var C = (r, e, t) => e in r ? m(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var d = (r, e, t) => (C(r, typeof e != "symbol" ? e + "" : e, t), t);
-import a, { useState as p, createContext as b, useContext as f, useId as E, useRef as v, useLayoutEffect as y } from "react";
-import { observable as u, makeObservable as g, action as h } from "mobx";
+var C = Object.defineProperty;
+var f = (i, e, t) => e in i ? C(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var o = (i, e, t) => (f(i, typeof e != "symbol" ? e + "" : e, t), t);
+import u, { useState as m, createContext as g, useContext as p, useId as E, useRef as b, useLayoutEffect as v } from "react";
+import { observable as h, makeObservable as w, action as a } from "mobx";
 import { observer as x } from "mobx-react-lite";
-const o = "default";
-class i {
+const l = "default";
+class d {
   constructor() {
-    d(this, "children", u.map(
+    o(this, "children", h.map(
       {},
       {
         deep: !1
       }
     ));
-    g(this, {
-      deleteChildren: h.bound,
-      setChildren: h.bound
+    o(this, "preparedChildren", /* @__PURE__ */ new Map());
+    w(this, {
+      deleteChildren: a.bound,
+      setChildren: a.bound
     });
   }
   static useNew() {
-    return p(new i())[0];
+    return m(new d())[0];
   }
-  setChildren(e = o, t, n) {
-    const s = this.children.get(e) ?? u.map({}, { deep: !1 });
-    s.set(t, n), this.children.set(e, s);
+  setChildren(e = l, t, n) {
+    var s;
+    const r = this.children.get(e) ?? h.map({}, { deep: !1 });
+    r.set(t, n), (s = this.preparedChildren.get(e)) == null || s.delete(t), this.children.set(e, r);
   }
-  deleteChildren(e = o, t) {
-    var n;
-    (n = this.children.get(e)) == null || n.delete(t);
+  prepareChildren(e = l, t, n) {
+    const r = this.preparedChildren.get(e) ?? /* @__PURE__ */ new Map();
+    r.set(t, n), this.preparedChildren.set(e, r);
   }
-  getChildren(e = o) {
-    var n;
-    const t = (n = this.children.get(e)) == null ? void 0 : n.entries();
+  deleteChildren(e = l, t) {
+    var n, r;
+    (n = this.children.get(e)) == null || n.delete(t), (r = this.preparedChildren.get(e)) == null || r.delete(t);
+  }
+  getChildren(e = l) {
+    var n, r;
+    const t = ((n = this.children.get(e)) == null ? void 0 : n.entries()) ?? ((r = this.preparedChildren.get(e)) == null ? void 0 : r.entries());
     if (t)
       return Array.from(t);
   }
 }
-const c = b(new i()), N = (r) => {
-  const { children: e } = r;
-  return /* @__PURE__ */ a.createElement(c.Provider, { value: i.useNew() }, e);
-}, P = (r) => {
-  const { children: e, id: t } = r, n = f(c), s = E(), l = v(!1);
-  return l.current || n.setChildren(t, s, e), y(() => (l.current = !0, n.setChildren(t, s, e), () => {
-    n.deleteChildren(t, s);
-  }), [e, t, s]), null;
-}, w = (r) => {
-  const { children: e } = r;
+const c = g(new d()), N = (i) => {
+  const { children: e } = i;
+  return /* @__PURE__ */ u.createElement(c.Provider, { value: d.useNew() }, e);
+}, P = (i) => {
+  const { children: e, id: t } = i, n = p(c), r = E(), s = b(!1);
+  return s.current || n.prepareChildren(t, r, e), v(() => (s.current = !0, n.setChildren(t, r, e), () => {
+    n.deleteChildren(t, r);
+  }), [e, t, r]), null;
+}, y = (i) => {
+  const { children: e } = i;
   return typeof e == "function" ? e() : e;
-}, A = x((r) => {
-  const { children: e, id: t } = r, n = f(c).getChildren(t);
-  return n ? n.map(([s, l]) => /* @__PURE__ */ a.createElement(w, { key: s }, l)) : e;
+}, A = x((i) => {
+  const { children: e, id: t } = i, n = p(c).getChildren(t);
+  return n ? n.map(([r, s]) => /* @__PURE__ */ u.createElement(y, { key: r }, s)) : e;
 });
 export {
   P as TunnelEntry,

package/dist/types/TunnelState.d.ts

@@ -3,9 +3,11 @@ import { TunnelChildren } from './types';
 
 export declare class TunnelState {
     readonly children: ObservableMap<string, ObservableMap<string, TunnelChildren>>;
+    private readonly preparedChildren;
     constructor();
     static useNew(): TunnelState;
     setChildren(tunnelId: string | undefined, entryId: string, children: TunnelChildren): void;
+    prepareChildren(tunnelId: string | undefined, entryId: string, children: TunnelChildren): void;
     deleteChildren(tunnelId: string | undefined, entryId: string): void;
     getChildren(tunnelId?: string): [string, TunnelChildren][] | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/react-tunnel",
-  "version": "0.1.0-alpha.115",
+  "version": "0.1.0-alpha.117",
   "type": "module",
   "description": "It's like a Portal – but with React components",
   "keywords": [
@@ -57,5 +57,5 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
-  "gitHead": "df23f3e3496ffaf3881a32e1e82209f5be473c6b"
+  "gitHead": "c61520c0afb82b14362f61743df779f05b62fdba"
 }