@gridland/core 0.2.30 → 0.2.31

package/dist/index.js

@@ -28805,17 +28805,167 @@ var OptimizedBuffer2 = class _OptimizedBuffer {
   }
 };
 
-// ../../opentui/packages/core/src/renderable-brand.ts
-var BrandedRenderable = /* @__PURE__ */ Symbol.for("@opentui/core/Renderable");
-function isRenderable2(obj) {
-  return !!obj?.[BrandedRenderable];
+// ../../opentui/packages/core/src/renderables/composition/vnode.ts
+import util from "node:util";
+var BrandedVNode = /* @__PURE__ */ Symbol.for("@opentui/core/VNode");
+function isRenderableConstructor(value) {
+  return typeof value === "function" && value.prototype && Renderable3.prototype.isPrototypeOf(value.prototype);
 }
-var _maybeMakeRenderable = null;
-function registerMaybeMakeRenderable(fn) {
-  _maybeMakeRenderable = fn;
+function flattenChildren(children) {
+  const result = [];
+  for (const child of children) {
+    if (Array.isArray(child)) {
+      result.push(...flattenChildren(child));
+    } else if (child !== null && child !== void 0 && child !== false) {
+      result.push(child);
+    }
+  }
+  return result;
+}
+function h(type, props, ...children) {
+  if (typeof type !== "function") {
+    throw new TypeError("h() received an invalid vnode type");
+  }
+  const vnode = {
+    [BrandedVNode]: true,
+    type,
+    props,
+    children: flattenChildren(children),
+    __pendingCalls: []
+  };
+  if (isRenderableConstructor(type)) {
+    return new Proxy(vnode, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        if (typeof prop === "string") {
+          const prototype = type.prototype;
+          const hasMethod = prototype && (typeof prototype[prop] === "function" || Object.getOwnPropertyDescriptor(prototype, prop) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(prototype), prop));
+          if (hasMethod) {
+            return (...args) => {
+              target.__pendingCalls = target.__pendingCalls || [];
+              target.__pendingCalls.push({ method: prop, args });
+              return target;
+            };
+          }
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        if (typeof prop === "string" && isRenderableConstructor(type)) {
+          const prototype = type.prototype;
+          const descriptor = Object.getOwnPropertyDescriptor(prototype, prop) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(prototype), prop);
+          if (descriptor && descriptor.set) {
+            target.__pendingCalls = target.__pendingCalls || [];
+            target.__pendingCalls.push({ method: prop, args: [value], isProperty: true });
+            return true;
+          }
+        }
+        return Reflect.set(target, prop, value, receiver);
+      }
+    });
+  }
+  return vnode;
+}
+function isVNode(node) {
+  return node && node[BrandedVNode];
 }
 function maybeMakeRenderable(ctx, node) {
-  return _maybeMakeRenderable?.(ctx, node) ?? null;
+  if (isRenderable(node)) return node;
+  if (isVNode(node)) return instantiate(ctx, node);
+  if (process.env.NODE_ENV !== "production") {
+    console.warn("maybeMakeRenderable received an invalid node", util.inspect(node, { depth: 2 }));
+  }
+  return null;
+}
+function wrapWithDelegates(instance, delegateMap) {
+  if (!delegateMap || Object.keys(delegateMap).length === 0) return instance;
+  const descendantCache = /* @__PURE__ */ new Map();
+  const getDescendant = (id) => {
+    if (descendantCache.has(id)) {
+      const cached = descendantCache.get(id);
+      if (cached !== void 0) {
+        return cached;
+      }
+    }
+    const descendant = instance.findDescendantById(id);
+    if (descendant) {
+      descendantCache.set(id, descendant);
+    }
+    return descendant;
+  };
+  const proxy = new Proxy(instance, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && delegateMap[prop]) {
+        const host = getDescendant(delegateMap[prop]);
+        if (host) {
+          const value = host[prop];
+          if (typeof value === "function") {
+            return value.bind(host);
+          }
+          return value;
+        }
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, receiver) {
+      if (typeof prop === "string" && delegateMap[prop]) {
+        const host = getDescendant(delegateMap[prop]);
+        if (host) {
+          return Reflect.set(host, prop, value);
+        }
+      }
+      return Reflect.set(target, prop, value, receiver);
+    }
+  });
+  return proxy;
+}
+function instantiate(ctx, node) {
+  if (isRenderable(node)) return node;
+  if (!node || typeof node !== "object") {
+    throw new TypeError("mount() received an invalid vnode");
+  }
+  const vnode = node;
+  const { type, props } = vnode;
+  const children = flattenChildren(vnode.children || []);
+  const delegateMap = vnode.__delegateMap;
+  if (isRenderableConstructor(type)) {
+    const instance = new type(ctx, props || {});
+    for (const child of children) {
+      if (isRenderable(child)) {
+        instance.add(child);
+      } else {
+        const mounted = instantiate(ctx, child);
+        instance.add(mounted);
+      }
+    }
+    const delegatedInstance = wrapWithDelegates(instance, delegateMap);
+    const pendingCalls = vnode.__pendingCalls;
+    if (pendingCalls) {
+      for (const call of pendingCalls) {
+        if (call.isProperty) {
+          ;
+          delegatedInstance[call.method] = call.args[0];
+        } else {
+          ;
+          delegatedInstance[call.method].apply(delegatedInstance, call.args);
+        }
+      }
+    }
+    return delegatedInstance;
+  }
+  const resolved = type(props || {}, children);
+  const inst = instantiate(ctx, resolved);
+  return wrapWithDelegates(inst, delegateMap);
+}
+function delegate(mapping, vnode) {
+  if (isRenderable(vnode)) {
+    return wrapWithDelegates(vnode, mapping);
+  }
+  if (!vnode || typeof vnode !== "object") return vnode;
+  vnode.__delegateMap = { ...vnode.__delegateMap || {}, ...mapping };
+  return vnode;
 }
 
 // ../../opentui/packages/core/src/lib/renderable.validations.ts
@@ -28892,6 +29042,7 @@ function isSizeType(value) {
 }
 
 // ../../opentui/packages/core/src/Renderable.ts
+var BrandedRenderable = /* @__PURE__ */ Symbol.for("@opentui/core/Renderable");
 var LayoutEvents = /* @__PURE__ */ ((LayoutEvents2) => {
   LayoutEvents2["LAYOUT_CHANGED"] = "layout-changed";
   LayoutEvents2["ADDED"] = "added";
@@ -28904,6 +29055,9 @@ var RenderableEvents = /* @__PURE__ */ ((RenderableEvents2) => {
   RenderableEvents2["BLURRED"] = "blurred";
   return RenderableEvents2;
 })(RenderableEvents || {});
+function isRenderable(obj) {
+  return !!obj?.[BrandedRenderable];
+}
 var BaseRenderable = class _BaseRenderable extends EventEmitter4 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
@@ -33527,170 +33681,6 @@ var RootTextNodeRenderable = class extends TextNodeRenderable {
   }
 };
 
-// ../../opentui/packages/core/src/renderables/composition/vnode.ts
-import util from "node:util";
-var BrandedVNode = /* @__PURE__ */ Symbol.for("@opentui/core/VNode");
-function isRenderableConstructor(value) {
-  return typeof value === "function" && value.prototype && !!value.prototype[BrandedRenderable];
-}
-function flattenChildren(children) {
-  const result = [];
-  for (const child of children) {
-    if (Array.isArray(child)) {
-      result.push(...flattenChildren(child));
-    } else if (child !== null && child !== void 0 && child !== false) {
-      result.push(child);
-    }
-  }
-  return result;
-}
-function h(type, props, ...children) {
-  if (typeof type !== "function") {
-    throw new TypeError("h() received an invalid vnode type");
-  }
-  const vnode = {
-    [BrandedVNode]: true,
-    type,
-    props,
-    children: flattenChildren(children),
-    __pendingCalls: []
-  };
-  if (isRenderableConstructor(type)) {
-    return new Proxy(vnode, {
-      get(target, prop, receiver) {
-        if (prop in target) {
-          return Reflect.get(target, prop, receiver);
-        }
-        if (typeof prop === "string") {
-          const prototype = type.prototype;
-          const hasMethod = prototype && (typeof prototype[prop] === "function" || Object.getOwnPropertyDescriptor(prototype, prop) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(prototype), prop));
-          if (hasMethod) {
-            return (...args) => {
-              target.__pendingCalls = target.__pendingCalls || [];
-              target.__pendingCalls.push({ method: prop, args });
-              return target;
-            };
-          }
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      set(target, prop, value, receiver) {
-        if (typeof prop === "string" && isRenderableConstructor(type)) {
-          const prototype = type.prototype;
-          const descriptor = Object.getOwnPropertyDescriptor(prototype, prop) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(prototype), prop);
-          if (descriptor && descriptor.set) {
-            target.__pendingCalls = target.__pendingCalls || [];
-            target.__pendingCalls.push({ method: prop, args: [value], isProperty: true });
-            return true;
-          }
-        }
-        return Reflect.set(target, prop, value, receiver);
-      }
-    });
-  }
-  return vnode;
-}
-function isVNode(node) {
-  return node && node[BrandedVNode];
-}
-function maybeMakeRenderable2(ctx, node) {
-  if (isRenderable2(node)) return node;
-  if (isVNode(node)) return instantiate(ctx, node);
-  if (process.env.NODE_ENV !== "production") {
-    console.warn("maybeMakeRenderable received an invalid node", util.inspect(node, { depth: 2 }));
-  }
-  return null;
-}
-registerMaybeMakeRenderable(maybeMakeRenderable2);
-function wrapWithDelegates(instance, delegateMap) {
-  if (!delegateMap || Object.keys(delegateMap).length === 0) return instance;
-  const descendantCache = /* @__PURE__ */ new Map();
-  const getDescendant = (id) => {
-    if (descendantCache.has(id)) {
-      const cached = descendantCache.get(id);
-      if (cached !== void 0) {
-        return cached;
-      }
-    }
-    const descendant = instance.findDescendantById(id);
-    if (descendant) {
-      descendantCache.set(id, descendant);
-    }
-    return descendant;
-  };
-  const proxy = new Proxy(instance, {
-    get(target, prop, receiver) {
-      if (typeof prop === "string" && delegateMap[prop]) {
-        const host = getDescendant(delegateMap[prop]);
-        if (host) {
-          const value = host[prop];
-          if (typeof value === "function") {
-            return value.bind(host);
-          }
-          return value;
-        }
-      }
-      return Reflect.get(target, prop, receiver);
-    },
-    set(target, prop, value, receiver) {
-      if (typeof prop === "string" && delegateMap[prop]) {
-        const host = getDescendant(delegateMap[prop]);
-        if (host) {
-          return Reflect.set(host, prop, value);
-        }
-      }
-      return Reflect.set(target, prop, value, receiver);
-    }
-  });
-  return proxy;
-}
-function instantiate(ctx, node) {
-  if (isRenderable2(node)) return node;
-  if (!node || typeof node !== "object") {
-    throw new TypeError("mount() received an invalid vnode");
-  }
-  const vnode = node;
-  const { type, props } = vnode;
-  const children = flattenChildren(vnode.children || []);
-  const delegateMap = vnode.__delegateMap;
-  if (isRenderableConstructor(type)) {
-    const instance = new type(ctx, props || {});
-    for (const child of children) {
-      if (isRenderable2(child)) {
-        instance.add(child);
-      } else {
-        const mounted = instantiate(ctx, child);
-        instance.add(mounted);
-      }
-    }
-    const delegatedInstance = wrapWithDelegates(instance, delegateMap);
-    const pendingCalls = vnode.__pendingCalls;
-    if (pendingCalls) {
-      for (const call of pendingCalls) {
-        if (call.isProperty) {
-          ;
-          delegatedInstance[call.method] = call.args[0];
-        } else {
-          ;
-          delegatedInstance[call.method].apply(delegatedInstance, call.args);
-        }
-      }
-    }
-    return delegatedInstance;
-  }
-  const resolved = type(props || {}, children);
-  const inst = instantiate(ctx, resolved);
-  return wrapWithDelegates(inst, delegateMap);
-}
-function delegate(mapping, vnode) {
-  if (isRenderable2(vnode)) {
-    return wrapWithDelegates(vnode, mapping);
-  }
-  if (!vnode || typeof vnode !== "object") return vnode;
-  vnode.__delegateMap = { ...vnode.__delegateMap || {}, ...mapping };
-  return vnode;
-}
-
 // ../../opentui/packages/core/src/renderables/composition/constructs.ts
 function Generic(props, ...children) {
   return h(VRenderable, props || {}, ...children);
@@ -48062,7 +48052,7 @@ function setProperty(instance, type, propKey, propValue, oldPropValue) {
       }
       break;
     case "focused":
-      if (isRenderable2(instance)) {
+      if (isRenderable(instance)) {
         if (!!propValue) {
           instance.focus();
         } else {
@@ -48538,7 +48528,7 @@ export {
   hexToRgb,
   hsvToRgb,
   instantiate,
-  isRenderable2 as isRenderable,
+  isRenderable,
   isStyledText,
   isTextNodeRenderable,
   isVNode,
@@ -48546,7 +48536,7 @@ export {
   italic,
   link,
   magenta,
-  maybeMakeRenderable2 as maybeMakeRenderable,
+  maybeMakeRenderable,
   measureText,
   nonAlphanumericKeys,
   parseAlign,