@juo/blocks 1.16.0 → 2.0.0-alpha.1

package/dist/block-BjJztStr.js

@@ -0,0 +1,993 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { getHook } from "./devtools.js";
+import { reportBlockError, reportBlockWarning } from "./observability.js";
+const createContext = (key) => key;
+class ContextRequestEvent extends Event {
+  constructor(context, callback, subscribe) {
+    super("context-request", { bubbles: true, composed: true });
+    this.context = context;
+    this.callback = callback;
+    this.subscribe = subscribe;
+  }
+}
+class ContextProvideEvent extends Event {
+  constructor(context, value, subscribe) {
+    super("context-provide", { bubbles: true, composed: true });
+    this.context = context;
+    this.value = value;
+    this.subscribe = subscribe;
+  }
+}
+function provideContext(target, context, init) {
+  var _a;
+  (_a = getHook()) == null ? void 0 : _a.emit("context:provide", { context: String(context) });
+  const ev = new ContextProvideEvent(context, init);
+  target.dispatchEvent(ev);
+}
+function injectContext(target, context) {
+  var _a;
+  let value = void 0;
+  (_a = getHook()) == null ? void 0 : _a.emit("context:request", { context: String(context) });
+  const ev = new ContextRequestEvent(context, (received) => {
+    value = received;
+  });
+  target.dispatchEvent(ev);
+  if (value === void 0) {
+    throw new Error(`Context '${context}' not defined`);
+  }
+  return value;
+}
+function subscribeContext(target, context, callback) {
+  var _a;
+  let unsubscribeFunction = null;
+  (_a = getHook()) == null ? void 0 : _a.emit("context:request", { context: String(context) });
+  const protocolCallback = (value, unsubscribe) => {
+    if (unsubscribe) {
+      unsubscribeFunction = unsubscribe;
+    }
+    callback(value);
+  };
+  const ev = new ContextRequestEvent(context, protocolCallback, true);
+  target.dispatchEvent(ev);
+  return () => {
+    if (unsubscribeFunction) {
+      unsubscribeFunction();
+    }
+  };
+}
+class ContextRoot extends HTMLElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "store", /* @__PURE__ */ new Map());
+    __publicField(this, "callbacks", /* @__PURE__ */ new Map());
+  }
+  connectedCallback() {
+    this.addEventListener("context-provide", (ev) => {
+      ev.stopPropagation();
+      this.store.set(ev.context, ev.value);
+      const registeredCallbacks = this.callbacks.get(ev.context) ?? [];
+      registeredCallbacks.forEach((cb) => {
+        const unsubscribe = () => {
+          const callbacks = this.callbacks.get(ev.context);
+          if (callbacks) {
+            const cbIndex = callbacks.indexOf(cb);
+            if (cbIndex > -1) {
+              callbacks.splice(cbIndex, 1);
+            }
+          }
+        };
+        cb(ev.value, unsubscribe);
+      });
+    });
+    this.addEventListener("context-request", (ev) => {
+      ev.stopPropagation();
+      const storedValue = this.store.get(ev.context);
+      if (ev.subscribe) {
+        let callbacks = this.callbacks.get(ev.context);
+        if (!callbacks) {
+          callbacks = [];
+          this.callbacks.set(ev.context, callbacks);
+        }
+        const unsubscribe = () => {
+          const currentCallbacks = this.callbacks.get(ev.context);
+          if (currentCallbacks) {
+            const index = currentCallbacks.indexOf(ev.callback);
+            if (index > -1) {
+              currentCallbacks.splice(index, 1);
+            }
+          }
+        };
+        callbacks.push(ev.callback);
+        if (storedValue !== void 0) {
+          ev.callback(storedValue, unsubscribe);
+        }
+      } else {
+        if (storedValue !== void 0) {
+          ev.callback(storedValue);
+        } else {
+          console.warn("Context not present in store: " + String(ev.context));
+        }
+      }
+    });
+  }
+}
+var i = Symbol.for("preact-signals");
+function t() {
+  if (!(s > 1)) {
+    var i2, t2 = false;
+    while (void 0 !== h) {
+      var r2 = h;
+      h = void 0;
+      f++;
+      while (void 0 !== r2) {
+        var o2 = r2.o;
+        r2.o = void 0;
+        r2.f &= -3;
+        if (!(8 & r2.f) && c(r2)) try {
+          r2.c();
+        } catch (r3) {
+          if (!t2) {
+            i2 = r3;
+            t2 = true;
+          }
+        }
+        r2 = o2;
+      }
+    }
+    f = 0;
+    s--;
+    if (t2) throw i2;
+  } else s--;
+}
+function r(i2) {
+  if (s > 0) return i2();
+  s++;
+  try {
+    return i2();
+  } finally {
+    t();
+  }
+}
+var o = void 0;
+function n(i2) {
+  var t2 = o;
+  o = void 0;
+  try {
+    return i2();
+  } finally {
+    o = t2;
+  }
+}
+var h = void 0, s = 0, f = 0, v = 0;
+function e(i2) {
+  if (void 0 !== o) {
+    var t2 = i2.n;
+    if (void 0 === t2 || t2.t !== o) {
+      t2 = { i: 0, S: i2, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t2 };
+      if (void 0 !== o.s) o.s.n = t2;
+      o.s = t2;
+      i2.n = t2;
+      if (32 & o.f) i2.S(t2);
+      return t2;
+    } else if (-1 === t2.i) {
+      t2.i = 0;
+      if (void 0 !== t2.n) {
+        t2.n.p = t2.p;
+        if (void 0 !== t2.p) t2.p.n = t2.n;
+        t2.p = o.s;
+        t2.n = void 0;
+        o.s.n = t2;
+        o.s = t2;
+      }
+      return t2;
+    }
+  }
+}
+function u(i2, t2) {
+  this.v = i2;
+  this.i = 0;
+  this.n = void 0;
+  this.t = void 0;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+}
+u.prototype.brand = i;
+u.prototype.h = function() {
+  return true;
+};
+u.prototype.S = function(i2) {
+  var t2 = this, r2 = this.t;
+  if (r2 !== i2 && void 0 === i2.e) {
+    i2.x = r2;
+    this.t = i2;
+    if (void 0 !== r2) r2.e = i2;
+    else n(function() {
+      var i3;
+      null == (i3 = t2.W) || i3.call(t2);
+    });
+  }
+};
+u.prototype.U = function(i2) {
+  var t2 = this;
+  if (void 0 !== this.t) {
+    var r2 = i2.e, o2 = i2.x;
+    if (void 0 !== r2) {
+      r2.x = o2;
+      i2.e = void 0;
+    }
+    if (void 0 !== o2) {
+      o2.e = r2;
+      i2.x = void 0;
+    }
+    if (i2 === this.t) {
+      this.t = o2;
+      if (void 0 === o2) n(function() {
+        var i3;
+        null == (i3 = t2.Z) || i3.call(t2);
+      });
+    }
+  }
+};
+u.prototype.subscribe = function(i2) {
+  var t2 = this;
+  return E(function() {
+    var r2 = t2.value, n2 = o;
+    o = void 0;
+    try {
+      i2(r2);
+    } finally {
+      o = n2;
+    }
+  });
+};
+u.prototype.valueOf = function() {
+  return this.value;
+};
+u.prototype.toString = function() {
+  return this.value + "";
+};
+u.prototype.toJSON = function() {
+  return this.value;
+};
+u.prototype.peek = function() {
+  var i2 = o;
+  o = void 0;
+  try {
+    return this.value;
+  } finally {
+    o = i2;
+  }
+};
+Object.defineProperty(u.prototype, "value", { get: function() {
+  var i2 = e(this);
+  if (void 0 !== i2) i2.i = this.i;
+  return this.v;
+}, set: function(i2) {
+  if (i2 !== this.v) {
+    if (f > 100) throw new Error("Cycle detected");
+    this.v = i2;
+    this.i++;
+    v++;
+    s++;
+    try {
+      for (var r2 = this.t; void 0 !== r2; r2 = r2.x) r2.t.N();
+    } finally {
+      t();
+    }
+  }
+} });
+function d(i2, t2) {
+  return new u(i2, t2);
+}
+function c(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) return true;
+  return false;
+}
+function a(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) {
+    var r2 = t2.S.n;
+    if (void 0 !== r2) t2.r = r2;
+    t2.S.n = t2;
+    t2.i = -1;
+    if (void 0 === t2.n) {
+      i2.s = t2;
+      break;
+    }
+  }
+}
+function l(i2) {
+  var t2 = i2.s, r2 = void 0;
+  while (void 0 !== t2) {
+    var o2 = t2.p;
+    if (-1 === t2.i) {
+      t2.S.U(t2);
+      if (void 0 !== o2) o2.n = t2.n;
+      if (void 0 !== t2.n) t2.n.p = o2;
+    } else r2 = t2;
+    t2.S.n = t2.r;
+    if (void 0 !== t2.r) t2.r = void 0;
+    t2 = o2;
+  }
+  i2.s = r2;
+}
+function y(i2, t2) {
+  u.call(this, void 0);
+  this.x = i2;
+  this.s = void 0;
+  this.g = v - 1;
+  this.f = 4;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+}
+y.prototype = new u();
+y.prototype.h = function() {
+  this.f &= -3;
+  if (1 & this.f) return false;
+  if (32 == (36 & this.f)) return true;
+  this.f &= -5;
+  if (this.g === v) return true;
+  this.g = v;
+  this.f |= 1;
+  if (this.i > 0 && !c(this)) {
+    this.f &= -2;
+    return true;
+  }
+  var i2 = o;
+  try {
+    a(this);
+    o = this;
+    var t2 = this.x();
+    if (16 & this.f || this.v !== t2 || 0 === this.i) {
+      this.v = t2;
+      this.f &= -17;
+      this.i++;
+    }
+  } catch (i3) {
+    this.v = i3;
+    this.f |= 16;
+    this.i++;
+  }
+  o = i2;
+  l(this);
+  this.f &= -2;
+  return true;
+};
+y.prototype.S = function(i2) {
+  if (void 0 === this.t) {
+    this.f |= 36;
+    for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.S(t2);
+  }
+  u.prototype.S.call(this, i2);
+};
+y.prototype.U = function(i2) {
+  if (void 0 !== this.t) {
+    u.prototype.U.call(this, i2);
+    if (void 0 === this.t) {
+      this.f &= -33;
+      for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+    }
+  }
+};
+y.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var i2 = this.t; void 0 !== i2; i2 = i2.x) i2.t.N();
+  }
+};
+Object.defineProperty(y.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var i2 = e(this);
+  this.h();
+  if (void 0 !== i2) i2.i = this.i;
+  if (16 & this.f) throw this.v;
+  return this.v;
+} });
+function w(i2, t2) {
+  return new y(i2, t2);
+}
+function _(i2) {
+  var r2 = i2.u;
+  i2.u = void 0;
+  if ("function" == typeof r2) {
+    s++;
+    var n2 = o;
+    o = void 0;
+    try {
+      r2();
+    } catch (t2) {
+      i2.f &= -2;
+      i2.f |= 8;
+      b(i2);
+      throw t2;
+    } finally {
+      o = n2;
+      t();
+    }
+  }
+}
+function b(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+  i2.x = void 0;
+  i2.s = void 0;
+  _(i2);
+}
+function g(i2) {
+  if (o !== this) throw new Error("Out-of-order effect");
+  l(this);
+  o = i2;
+  this.f &= -2;
+  if (8 & this.f) b(this);
+  t();
+}
+function p(i2) {
+  this.x = i2;
+  this.u = void 0;
+  this.s = void 0;
+  this.o = void 0;
+  this.f = 32;
+}
+p.prototype.c = function() {
+  var i2 = this.S();
+  try {
+    if (8 & this.f) return;
+    if (void 0 === this.x) return;
+    var t2 = this.x();
+    if ("function" == typeof t2) this.u = t2;
+  } finally {
+    i2();
+  }
+};
+p.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1;
+  this.f &= -9;
+  _(this);
+  a(this);
+  s++;
+  var i2 = o;
+  o = this;
+  return g.bind(this, i2);
+};
+p.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 2;
+    this.o = h;
+    h = this;
+  }
+};
+p.prototype.d = function() {
+  this.f |= 8;
+  if (!(1 & this.f)) b(this);
+};
+p.prototype.dispose = function() {
+  this.d();
+};
+function E(i2) {
+  var t2 = new p(i2);
+  try {
+    t2.c();
+  } catch (i3) {
+    t2.d();
+    throw i3;
+  }
+  var r2 = t2.d.bind(t2);
+  r2[Symbol.dispose] = r2;
+  return r2;
+}
+function isEditorPreview() {
+  if (typeof window === "undefined") return false;
+  return new URLSearchParams(window.location.search).get("editor") === "true";
+}
+const layoutSystemEnabled = d(false);
+function setLayoutSystemEnabled(enabled) {
+  if (layoutSystemEnabled.peek() === enabled) return;
+  layoutSystemEnabled.value = enabled;
+}
+function hasRenderedContent(scope) {
+  var _a;
+  for (const child of scope.children) {
+    if (!(child instanceof HTMLElement)) {
+      continue;
+    }
+    const display = (_a = child.ownerDocument.defaultView) == null ? void 0 : _a.getComputedStyle(child).display;
+    if (display === "contents") {
+      if (hasRenderedContent(child)) {
+        return true;
+      }
+      continue;
+    }
+    if (child.checkVisibility()) {
+      return true;
+    }
+  }
+  return false;
+}
+function attachEmptyTracking(host, scope) {
+  let observer = null;
+  let disposed = false;
+  queueMicrotask(() => {
+    if (disposed) return;
+    const observed = scope ?? host.shadowRoot ?? host;
+    const sync = () => host.toggleAttribute("data-empty", !hasRenderedContent(observed));
+    observer = new MutationObserver(sync);
+    observer.observe(observed, { childList: true, subtree: true });
+    sync();
+  });
+  return () => {
+    disposed = true;
+    observer == null ? void 0 : observer.disconnect();
+    observer = null;
+  };
+}
+function serializeBlocks(blocks) {
+  return blocks.map((block) => serializeBlock(block));
+}
+function serializeBlock(block) {
+  return {
+    id: block.id,
+    type: block.type,
+    props: JSON.parse(JSON.stringify(block.props)),
+    slots: Object.fromEntries(
+      Object.entries(block.slots ?? {}).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(
+          (v2) => typeof v2 === "string" ? v2 : serializeBlock(v2)
+        ) : typeof value === "string" ? value : serializeBlock(value)
+      ])
+    )
+  };
+}
+function createSelectedBlock() {
+  const selected = d(null);
+  function setSelection(block) {
+    selected.value = null;
+    selected.value = block;
+  }
+  function clearSelection(block) {
+    var _a;
+    if (block == null || ((_a = selected.value) == null ? void 0 : _a.id) === block.id) {
+      selected.value = null;
+    }
+  }
+  return { selected, setSelection, clearSelection };
+}
+const SelectedBlockContext = createContext("selectedBlock");
+const blockDefinitions = (() => {
+  if (typeof window !== "undefined") {
+    window._juoBlocks = window._juoBlocks || /* @__PURE__ */ new Map();
+    return window._juoBlocks;
+  }
+  return /* @__PURE__ */ new Map();
+})();
+class BlockWrapperEvent extends Event {
+  constructor(block, callback) {
+    super("juo:block-wrapper-render", {
+      bubbles: true,
+      composed: true,
+      cancelable: true
+    });
+    this.block = block;
+    this.callback = callback;
+  }
+}
+function getDevtoolsState() {
+  const hook = getHook();
+  if (!hook) return null;
+  const holder = hook;
+  if (!holder.__blockDevtoolsState) {
+    holder.__blockDevtoolsState = {
+      instances: /* @__PURE__ */ new Map(),
+      propSetters: /* @__PURE__ */ new Map(),
+      propOverrides: /* @__PURE__ */ new Map()
+    };
+  }
+  return holder.__blockDevtoolsState;
+}
+function applyDevtoolsPropOverride(id, props) {
+  var _a;
+  const override = (_a = getDevtoolsState()) == null ? void 0 : _a.propOverrides.get(id);
+  return override ? { ...props, ...override } : props;
+}
+function __recordDevtoolsPropSetter(id, setProp) {
+  var _a;
+  (_a = getDevtoolsState()) == null ? void 0 : _a.propSetters.set(id, setProp);
+}
+function __recordDevtoolsInstance(inst) {
+  var _a;
+  (_a = getDevtoolsState()) == null ? void 0 : _a.instances.set(inst.id, {
+    type: inst.type,
+    props: inst.props,
+    el: inst.el
+  });
+}
+function __clearDevtoolsBlockState(id) {
+  const state = getDevtoolsState();
+  if (!state) return;
+  state.instances.delete(id);
+  state.propSetters.delete(id);
+  state.propOverrides.delete(id);
+}
+function getDevtoolsPropsSchema(type) {
+  var _a;
+  const def = blockDefinitions.get(type);
+  const schema = def == null ? void 0 : def.schema;
+  const props = (_a = schema == null ? void 0 : schema.properties) == null ? void 0 : _a.props;
+  return props && typeof props === "object" ? props : null;
+}
+function getDevtoolsBlockState(id) {
+  var _a;
+  const inst = (_a = getDevtoolsState()) == null ? void 0 : _a.instances.get(id);
+  if (!inst) return null;
+  return {
+    props: applyDevtoolsPropOverride(id, inst.props),
+    propsSchema: getDevtoolsPropsSchema(inst.type)
+  };
+}
+function setDevtoolsBlockProp(id, key, value) {
+  const state = getDevtoolsState();
+  const inst = state == null ? void 0 : state.instances.get(id);
+  if (!state || !inst) return null;
+  state.propOverrides.set(id, {
+    ...state.propOverrides.get(id) ?? {},
+    [key]: value
+  });
+  const setter = state.propSetters.get(id);
+  if (setter) {
+    setter(key, value);
+  } else if (inst.el) {
+    inst.el[key] = value;
+  }
+  return { props: applyDevtoolsPropOverride(id, inst.props) };
+}
+function getDevtoolsBlockCatalog() {
+  const catalog = {};
+  for (const def of getDefinedBlocks()) {
+    catalog[def.name] = def.displayName ?? def.name;
+  }
+  return catalog;
+}
+function attachDevtoolsResolvers(hook) {
+  if (hook.resolvers) return;
+  hook.resolvers = {
+    getBlockState: getDevtoolsBlockState,
+    setBlockProp: setDevtoolsBlockProp,
+    getBlockCatalog: getDevtoolsBlockCatalog
+  };
+}
+function withWrapper(fn) {
+  let wrapper = null;
+  return (block) => {
+    var _a;
+    let rendered;
+    try {
+      rendered = fn(block);
+    } catch (error) {
+      reportBlockError(error, {
+        site: "block.withWrapper",
+        block: { id: block.id, type: block.type, definition: block.definition },
+        keys: {
+          props: Object.keys(block.props ?? {}),
+          slots: Object.keys(block.slots ?? {})
+        }
+      });
+      rendered = createStubDefinition(block.type).render(block);
+    }
+    const devtoolsHook = getHook();
+    if (devtoolsHook) {
+      attachDevtoolsResolvers(devtoolsHook);
+      __recordDevtoolsInstance({
+        id: block.id,
+        type: block.type,
+        props: block.props ?? {},
+        el: rendered
+      });
+      devtoolsHook.emit("block:mounted", {
+        id: block.id,
+        type: block.type,
+        slot: null,
+        parentId: null,
+        propKeys: Object.keys(block.props ?? {})
+      });
+    }
+    if (wrapper === null) {
+      if (isEditorPreview()) {
+        wrapper = document.createElement(
+          layoutSystemEnabled.value ? "juo-editor-layout-block-wrapper" : "juo-editor-block-wrapper"
+        );
+        wrapper.setAttribute("data-block-id", block.id);
+        (_a = wrapper.setBlock) == null ? void 0 : _a.call(wrapper, block);
+        wrapper.appendChild(rendered);
+      } else {
+        const evt = new BlockWrapperEvent(block, (evtWrapper) => {
+          wrapper = evtWrapper;
+        });
+        document.dispatchEvent(evt);
+      }
+    }
+    if (!wrapper) {
+      return rendered;
+    }
+    wrapper.replaceChildren(rendered);
+    return wrapper;
+  };
+}
+const registerBlockListeners = [];
+function registerBlock(block) {
+  blockDefinitions.set(block.name, block);
+  stubDefinitionCache.delete(block.name);
+  registerBlockListeners.forEach((cb) => cb(block.name, block));
+  const regHook = getHook();
+  if (regHook) {
+    attachDevtoolsResolvers(regHook);
+    regHook.emit("block:registered", {
+      name: block.name,
+      group: block.group,
+      displayName: block.displayName ?? block.name
+    });
+  }
+}
+function onRegisterBlock(cb) {
+  registerBlockListeners.push(cb);
+  return () => {
+    const idx = registerBlockListeners.indexOf(cb);
+    if (idx >= 0) registerBlockListeners.splice(idx, 1);
+  };
+}
+function defineBlock(name, opts) {
+  const definition = {
+    name,
+    displayName: opts.displayName,
+    group: opts.group,
+    schema: opts.schema,
+    initialValue: opts.initialValue,
+    render: opts.renderer,
+    presets: opts.presets,
+    locales: opts.locales
+  };
+  return definition;
+}
+function defineBlockRuntime(name, opts) {
+  const definition = {
+    name,
+    displayName: opts.displayName,
+    group: opts.group,
+    schema: {},
+    initialValue() {
+      throw new Error("Initial value cannot be called in runtime mode");
+    },
+    render: opts.renderer
+  };
+  return definition;
+}
+function getDefinedBlocks() {
+  return [...blockDefinitions.values()];
+}
+function createCeRenderer(name) {
+  function renderSlots(slots, block) {
+    if (!slots) {
+      return slots;
+    }
+    return Object.entries(slots).flatMap(([key, value]) => {
+      const values = Array.isArray(value) ? value : [value];
+      return values.flatMap((value2) => {
+        if (typeof value2 === "string") {
+          const el = document.createElement("span");
+          if (key !== "default") {
+            el.slot = key;
+          }
+          el.innerText = value2;
+          return [el];
+        }
+        try {
+          const el = value2.definition.render({
+            ...value2,
+            props: {
+              ...value2.props,
+              parentProps: block.props
+            }
+          });
+          if (key !== "default") {
+            el.slot = key;
+          }
+          return [el];
+        } catch (error) {
+          reportBlockError(error, {
+            site: "block.createCeRenderer.renderSlots",
+            block: { id: value2.id, type: value2.type, definition: value2.definition },
+            extra: {
+              parentBlockId: block.id,
+              parentBlockType: block.type,
+              slotKey: key
+            }
+          });
+          return [];
+        }
+      });
+    });
+  }
+  return (block) => {
+    const el = document.createElement(name);
+    el.setAttribute("data-block-id", block.id);
+    el.setAttribute("data-block-type", block.type);
+    Object.entries(applyDevtoolsPropOverride(block.id, block.props)).forEach(
+      ([key, value]) => {
+        el[key] = value;
+      }
+    );
+    el.replaceChildren(...renderSlots(block.slots, block));
+    attachEmptyTracking(el);
+    return el;
+  };
+}
+const stubDefinitionCache = /* @__PURE__ */ new Map();
+function createStubDefinition(name) {
+  const cached = stubDefinitionCache.get(name);
+  if (cached) return cached;
+  const stub = {
+    name,
+    group: "internal",
+    schema: {},
+    initialValue: { props: {}, slots: {} },
+    __stub: true,
+    render() {
+      const el = document.createElement("div");
+      el.dataset.stubBlock = name;
+      if (isEditorPreview()) {
+        el.textContent = `Block definition not found: ${name}`;
+      } else {
+        el.style.display = "none";
+      }
+      return el;
+    }
+  };
+  stubDefinitionCache.set(name, stub);
+  reportBlockWarning(`Block definition '${name}' not found`, {
+    site: "block.createStubDefinition",
+    block: { id: "(none)", type: name }
+  });
+  console.warn(
+    `[juo/blocks] Block definition '${name}' not found. This block may have been removed or renamed. Rendering a hidden stub.`
+  );
+  return stub;
+}
+function isStubDefinition(definition) {
+  return definition.__stub === true;
+}
+function backfillInstanceDefaults(block) {
+  if (Object.keys(block.props ?? {}).length > 0) return false;
+  if (Object.keys(block.slots ?? {}).length > 0) return false;
+  if (isStubDefinition(block.definition)) return false;
+  let defaults;
+  try {
+    const iv = block.definition.initialValue;
+    defaults = (typeof iv === "function" ? iv() : iv) ?? {};
+  } catch (error) {
+    reportBlockError(error, {
+      site: "block.backfillInstanceDefaults",
+      block: { id: block.id, type: block.type, definition: block.definition }
+    });
+    return false;
+  }
+  const propsDefault = defaults.props ?? {};
+  const slotsDefault = defaults.slots ?? {};
+  const hasProps = Object.keys(propsDefault).length > 0;
+  const hasSlots = Object.keys(slotsDefault).length > 0;
+  if (!hasProps && !hasSlots) return false;
+  if (hasProps) Object.assign(block.props, propsDefault);
+  if (hasSlots) Object.assign(block.slots, slotsDefault);
+  return true;
+}
+function getDefinitionByName(name) {
+  const definition = blockDefinitions.get(name);
+  if (definition != null) {
+    return definition;
+  }
+  return createStubDefinition(name);
+}
+function createBlockInstance(name, opts) {
+  const initialValue = (() => {
+    const value = getDefinitionByName(name).initialValue ?? {};
+    if (typeof value === "function") {
+      return value();
+    }
+    return value;
+  })();
+  if ((opts == null ? void 0 : opts.props) == null && initialValue == null) {
+    const error = new Error(
+      `Block '${name}' cannot be created without value in runtime mode`
+    );
+    reportBlockError(error, {
+      site: "block.createBlockInstance",
+      block: { id: "(none)", type: name }
+    });
+    throw error;
+  }
+  const slots = {
+    ...initialValue.slots,
+    ...(opts == null ? void 0 : opts.slots) ?? {}
+  };
+  const props = {
+    ...initialValue.props ?? {},
+    ...(opts == null ? void 0 : opts.props) ?? {}
+  };
+  return {
+    // TODO: This should be unique
+    id: (opts == null ? void 0 : opts.id) ?? Math.round(1e3 * Math.random()).toString(10),
+    type: name,
+    props,
+    slots,
+    get definition() {
+      return getDefinitionByName(name);
+    }
+  };
+}
+function createBlockInstanceFromObject(input) {
+  const { id, type, props, slots } = input;
+  return createBlockInstance(type, {
+    props,
+    slots: Object.fromEntries(
+      Object.entries(slots).map(([key, value]) => [
+        key,
+        (Array.isArray(value) ? value : [value]).map(
+          (child) => createBlockInstanceFromObject(child)
+        )
+      ])
+    ),
+    id
+  });
+}
+function createBlockInstanceFromJSON(input) {
+  try {
+    return createBlockInstanceFromObject(JSON.parse(input));
+  } catch (error) {
+    reportBlockError(error, {
+      site: "block.createBlockInstanceFromJSON",
+      extra: { inputLength: input.length }
+    });
+    throw error;
+  }
+}
+export {
+  createSelectedBlock as A,
+  BlockWrapperEvent as B,
+  ContextRoot as C,
+  defineBlockRuntime as D,
+  E,
+  getDevtoolsBlockState as F,
+  hasRenderedContent as G,
+  isEditorPreview as H,
+  layoutSystemEnabled as I,
+  provideContext as J,
+  setDevtoolsBlockProp as K,
+  n as L,
+  SelectedBlockContext as S,
+  __recordDevtoolsPropSetter as _,
+  applyDevtoolsPropOverride as a,
+  isStubDefinition as b,
+  backfillInstanceDefaults as c,
+  __clearDevtoolsBlockState as d,
+  createContext as e,
+  d as f,
+  createBlockInstanceFromObject as g,
+  createBlockInstance as h,
+  injectContext as i,
+  getDefinedBlocks as j,
+  serializeBlocks as k,
+  setLayoutSystemEnabled as l,
+  w as m,
+  defineBlock as n,
+  onRegisterBlock as o,
+  registerBlock as p,
+  ContextProvideEvent as q,
+  r,
+  subscribeContext as s,
+  ContextRequestEvent as t,
+  u,
+  __recordDevtoolsInstance as v,
+  withWrapper as w,
+  attachEmptyTracking as x,
+  createBlockInstanceFromJSON as y,
+  createCeRenderer as z
+};