sibujs 1.0.0-beta.1

package/dist/ecosystem.cjs

@@ -0,0 +1,1046 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ecosystem.ts
+var ecosystem_exports = {};
+__export(ecosystem_exports, {
+  antdAdapter: () => antdAdapter,
+  chakraAdapter: () => chakraAdapter,
+  componentAdapter: () => componentAdapter,
+  createTheme: () => createTheme,
+  materialAdapter: () => materialAdapter,
+  mobXAdapter: () => mobXAdapter,
+  reduxAdapter: () => reduxAdapter,
+  zustandAdapter: () => zustandAdapter
+});
+module.exports = __toCommonJS(ecosystem_exports);
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s = sig;
+      s._d = false;
+      s._v = s._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        pendingQueue[i]();
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          pendingQueue[i2]();
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+
+// src/core/signals/effect.ts
+function effect(effectFn) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  let runCount = 0;
+  let cleanupHandle = () => {
+  };
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  const subscriber = () => {
+    cleanupHandle();
+    runCount++;
+    if (hook) hook.emit("effect:run", { effectFn, runCount });
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  runCount = 1;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    if (hook) hook.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal2 of signals) {
+    queueSignalNotification(signal2);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/plugins/plugin.ts
+function createPlugin(name, install) {
+  return { name, install };
+}
+
+// src/ecosystem/adapters/mobx.ts
+function mobXAdapter(options) {
+  return createPlugin("sibu-mobx", (ctx) => {
+    const { autorun } = options;
+    const disposers = [];
+    function fromMobX(expression) {
+      const [getValue, setValue] = signal(expression());
+      const disposer = autorun(() => {
+        const newValue = expression();
+        batch(() => {
+          setValue(newValue);
+        });
+      });
+      disposers.push(disposer);
+      return getValue;
+    }
+    function toMobX(sibuGetter, callback) {
+      return effect(() => {
+        callback(sibuGetter());
+      });
+    }
+    function destroy() {
+      for (const disposer of disposers) {
+        disposer();
+      }
+      disposers.length = 0;
+    }
+    const api = { fromMobX, toMobX, destroy };
+    ctx.provide("mobx", api);
+  });
+}
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    cs._d = false;
+    cs._v = getter();
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  function computedGetter() {
+    if (trackingSuspended) {
+      if (cs._d) {
+        cs._d = false;
+        cs._v = getter();
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+// src/ecosystem/adapters/redux.ts
+function reduxAdapter(options) {
+  return createPlugin("sibu-redux", (ctx) => {
+    const { store } = options;
+    const [getState, setState] = signal(store.getState());
+    const unsubscribe = store.subscribe(() => {
+      batch(() => {
+        setState(store.getState());
+      });
+    });
+    function useSelector(selector) {
+      return derived(() => selector(getState()));
+    }
+    const api = {
+      getState,
+      useSelector,
+      dispatch: store.dispatch.bind(store),
+      destroy: unsubscribe
+    };
+    ctx.provide("redux", api);
+  });
+}
+
+// src/ecosystem/adapters/zustand.ts
+function zustandAdapter(options) {
+  return createPlugin("sibu-zustand", (ctx) => {
+    const { store } = options;
+    const [getState, setSibuState] = signal(store.getState());
+    const unsubscribe = store.subscribe((state) => {
+      batch(() => {
+        setSibuState(state);
+      });
+    });
+    function useSelector(selector) {
+      return derived(() => selector(getState()));
+    }
+    const api = {
+      getState,
+      useSelector,
+      setState: store.setState.bind(store),
+      destroy() {
+        unsubscribe();
+        store.destroy();
+      }
+    };
+    ctx.provide("zustand", api);
+  });
+}
+
+// src/utils/sanitize.ts
+function sanitize(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(url) {
+  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  if (!trimmed) return "";
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
+    return "";
+  }
+  return trimmed;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr);
+}
+function sanitizeAttribute(attr, value) {
+  if (isUrlAttribute(attr)) {
+    return sanitizeUrl(value);
+  }
+  return sanitize(value);
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch {
+      return;
+    }
+    if (typeof value === "boolean") {
+      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
+        el[attr] = value;
+      } else if (value) {
+        el.setAttribute(attr, "");
+      } else {
+        el.removeAttribute(attr);
+      }
+      return;
+    }
+    const str = sanitizeAttribute(attr, String(value));
+    if ((attr === "value" || attr === "checked") && attr in el) {
+      el[attr] = attr === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(attr, str);
+    }
+  }
+  const teardown = track(commit);
+  return teardown;
+}
+
+// src/reactivity/bindChildNode.ts
+function bindChildNode(placeholder, getter) {
+  let lastNodes = [];
+  function commit() {
+    let result;
+    try {
+      result = getter();
+    } catch {
+      return;
+    }
+    for (const node of lastNodes) {
+      node.parentNode?.removeChild(node);
+    }
+    lastNodes = [];
+    if (result == null) return;
+    const parent = placeholder.parentNode;
+    if (!parent) return;
+    const anchor = placeholder.nextSibling;
+    const newNodes = [];
+    const insertItem = (item) => {
+      const node = item instanceof Node ? item : document.createTextNode(String(item));
+      parent.insertBefore(node, anchor);
+      newNodes.push(node);
+    };
+    if (Array.isArray(result)) {
+      for (const item of result) insertItem(item);
+    } else {
+      insertItem(result);
+    }
+    lastNodes = newNodes;
+  }
+  return track(commit);
+}
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var activeBindingCount = 0;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  activeBindingCount++;
+}
+
+// src/core/rendering/tagFactory.ts
+var kebabCache = /* @__PURE__ */ new Map();
+function toKebab(prop) {
+  let cached = kebabCache.get(prop);
+  if (cached !== void 0) return cached;
+  cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+  kebabCache.set(prop, cached);
+  return cached;
+}
+function applyStyle(el, style) {
+  if (!style) return;
+  if (typeof style === "function") {
+    const teardown = track(() => {
+      el.setAttribute("style", style());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof style === "string") {
+    el.setAttribute("style", style);
+    return;
+  }
+  const htmlEl = el;
+  for (const prop in style) {
+    const val = style[prop];
+    const name = toKebab(prop);
+    if (typeof val === "function") {
+      const getter = val;
+      const teardown = track(() => {
+        htmlEl.style.setProperty(name, String(getter()));
+      });
+      registerDisposer(el, teardown);
+    } else {
+      htmlEl.style.setProperty(name, String(val));
+    }
+  }
+}
+function applyClass(el, cls) {
+  if (cls == null) return;
+  if (typeof cls === "string") {
+    el.setAttribute("class", cls);
+    return;
+  }
+  if (typeof cls === "function") {
+    const getter = cls;
+    const teardown = track(() => {
+      el.setAttribute("class", getter());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof cls === "object") {
+    const obj = cls;
+    let hasReactive = false;
+    for (const name in obj) {
+      if (typeof obj[name] === "function") {
+        hasReactive = true;
+        break;
+      }
+    }
+    if (hasReactive) {
+      const update = () => {
+        let result = "";
+        for (const name in obj) {
+          const val = obj[name];
+          const active = typeof val === "function" ? val() : val;
+          if (active) result = result ? `${result} ${name}` : name;
+        }
+        el.setAttribute("class", result);
+      };
+      const teardown = track(update);
+      registerDisposer(el, teardown);
+    } else {
+      let result = "";
+      for (const name in obj) {
+        if (obj[name]) result = result ? `${result} ${name}` : name;
+      }
+      el.setAttribute("class", result);
+    }
+  }
+}
+function renderChild(child) {
+  if (child == null) {
+    return document.createTextNode("");
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  return document.createTextNode(String(child));
+}
+function appendOneChild(el, child) {
+  if (typeof child === "function") {
+    const placeholder = document.createComment("bind:child");
+    el.appendChild(placeholder);
+    const teardown = bindChildNode(placeholder, child);
+    registerDisposer(el, teardown);
+  } else {
+    el.appendChild(renderChild(child));
+  }
+}
+function appendChildren(el, nodes) {
+  if (Array.isArray(nodes)) {
+    for (let i = 0; i < nodes.length; i++) {
+      const c = nodes[i];
+      if (Array.isArray(c)) {
+        for (let j = 0; j < c.length; j++) {
+          appendOneChild(el, c[j]);
+        }
+      } else {
+        appendOneChild(el, c);
+      }
+    }
+  } else {
+    appendOneChild(el, nodes);
+  }
+}
+function isTagProps(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Node);
+}
+var tagFactory = (tag, ns) => (first, second) => {
+  let props;
+  if (first === void 0) {
+    props = {};
+  } else if (isTagProps(first)) {
+    props = first;
+  } else if (second !== void 0) {
+    props = { class: first, nodes: second };
+  } else {
+    props = { nodes: first };
+  }
+  const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+  for (const key in props) {
+    const value = props[key];
+    if (value == null) continue;
+    switch (key) {
+      case "id":
+        el.id = value;
+        break;
+      case "class":
+        applyClass(el, value);
+        break;
+      case "style":
+        applyStyle(el, value);
+        break;
+      case "ref":
+        if (value && typeof value === "object" && "current" in value) {
+          value.current = el;
+        }
+        break;
+      case "on": {
+        const handlers = value;
+        const eventNames = [];
+        for (const ev in handlers) {
+          el.addEventListener(ev, handlers[ev]);
+          eventNames.push(ev);
+        }
+        if (eventNames.length) {
+          el.__sibu_events__ = eventNames;
+        }
+        break;
+      }
+      case "nodes":
+        appendChildren(el, value);
+        break;
+      default:
+        if (key.toLowerCase().startsWith("on")) break;
+        if (typeof value === "function") {
+          const teardown = bindAttribute(el, key, value);
+          registerDisposer(el, teardown);
+        } else if (typeof value === "boolean") {
+          if (value) el.setAttribute(key, "");
+          else el.removeAttribute(key);
+        } else {
+          el.setAttribute(key, sanitizeAttribute(key, String(value)));
+        }
+    }
+  }
+  return el;
+};
+
+// src/ecosystem/ui/componentAdapter.ts
+function createTheme(initial) {
+  const [getConfig, setConfig] = signal(initial);
+  function resolveClass(component, variant) {
+    const config = getConfig();
+    const overrideKey = variant ? `${component}-${variant}` : component;
+    if (config.classOverrides?.[overrideKey]) {
+      return config.classOverrides[overrideKey];
+    }
+    const base = `${config.prefix}-${component}`;
+    return variant ? `${base} ${config.prefix}-${component}--${variant}` : base;
+  }
+  function setTheme(partial) {
+    setConfig((prev) => ({ ...prev, ...partial }));
+  }
+  return { config: getConfig, setTheme, resolveClass };
+}
+function componentAdapter(config) {
+  const theme = createTheme({ prefix: config.prefix });
+  const components = {};
+  for (const [name, mapping] of Object.entries(config.components)) {
+    const factory = tagFactory(mapping.tag || "div");
+    components[name] = (props = {}) => {
+      const { variant, size, class: userClass, ...rest } = props;
+      const classes = [mapping.baseClass];
+      if (variant && mapping.variants?.[variant]) {
+        classes.push(mapping.variants[variant]);
+      }
+      if (size && mapping.sizes?.[size]) {
+        classes.push(mapping.sizes[size]);
+      }
+      let finalClass;
+      if (typeof userClass === "function") {
+        finalClass = () => {
+          const extra = userClass();
+          return extra ? `${classes.join(" ")} ${extra}` : classes.join(" ");
+        };
+      } else if (typeof userClass === "string" && userClass) {
+        finalClass = `${classes.join(" ")} ${userClass}`;
+      } else {
+        finalClass = classes.join(" ");
+      }
+      const mergedProps = {
+        ...mapping.defaultProps,
+        ...rest,
+        class: finalClass
+      };
+      return factory(mergedProps);
+    };
+  }
+  return { name: config.name, components, theme };
+}
+
+// src/ecosystem/ui/antd.ts
+var antdConfig = {
+  name: "antd",
+  prefix: "ant",
+  components: {
+    Button: {
+      tag: "button",
+      baseClass: "ant-btn",
+      variants: {
+        primary: "ant-btn-primary",
+        dashed: "ant-btn-dashed",
+        text: "ant-btn-text",
+        link: "ant-btn-link",
+        default: "ant-btn-default",
+        danger: "ant-btn-dangerous"
+      },
+      sizes: {
+        sm: "ant-btn-sm",
+        lg: "ant-btn-lg"
+      },
+      defaultProps: { type: "button" }
+    },
+    Input: {
+      tag: "input",
+      baseClass: "ant-input",
+      sizes: {
+        sm: "ant-input-sm",
+        lg: "ant-input-lg"
+      }
+    },
+    Card: {
+      tag: "div",
+      baseClass: "ant-card",
+      variants: {
+        bordered: "ant-card-bordered"
+      }
+    },
+    Modal: {
+      tag: "div",
+      baseClass: "ant-modal"
+    },
+    Tag: {
+      tag: "span",
+      baseClass: "ant-tag",
+      variants: {
+        success: "ant-tag-success",
+        error: "ant-tag-error",
+        warning: "ant-tag-warning",
+        processing: "ant-tag-processing"
+      }
+    },
+    Badge: {
+      tag: "span",
+      baseClass: "ant-badge"
+    },
+    Avatar: {
+      tag: "span",
+      baseClass: "ant-avatar",
+      sizes: {
+        sm: "ant-avatar-sm",
+        lg: "ant-avatar-lg"
+      }
+    }
+  }
+};
+var antdAdapter = componentAdapter(antdConfig);
+
+// src/ecosystem/ui/chakra.ts
+var chakraConfig = {
+  name: "chakra",
+  prefix: "chakra",
+  components: {
+    Button: {
+      tag: "button",
+      baseClass: "chakra-button",
+      variants: {
+        solid: "chakra-button--solid",
+        outline: "chakra-button--outline",
+        ghost: "chakra-button--ghost",
+        link: "chakra-button--link"
+      },
+      sizes: {
+        xs: "chakra-button--xs",
+        sm: "chakra-button--sm",
+        md: "chakra-button--md",
+        lg: "chakra-button--lg"
+      },
+      defaultProps: { type: "button" }
+    },
+    Input: {
+      tag: "input",
+      baseClass: "chakra-input",
+      variants: {
+        outline: "chakra-input--outline",
+        filled: "chakra-input--filled",
+        flushed: "chakra-input--flushed",
+        unstyled: "chakra-input--unstyled"
+      },
+      sizes: {
+        xs: "chakra-input--xs",
+        sm: "chakra-input--sm",
+        md: "chakra-input--md",
+        lg: "chakra-input--lg"
+      }
+    },
+    Card: {
+      tag: "div",
+      baseClass: "chakra-card",
+      variants: {
+        elevated: "chakra-card--elevated",
+        outline: "chakra-card--outline",
+        filled: "chakra-card--filled",
+        unstyled: "chakra-card--unstyled"
+      }
+    },
+    Modal: {
+      tag: "div",
+      baseClass: "chakra-modal__content"
+    },
+    Badge: {
+      tag: "span",
+      baseClass: "chakra-badge",
+      variants: {
+        solid: "chakra-badge--solid",
+        subtle: "chakra-badge--subtle",
+        outline: "chakra-badge--outline"
+      }
+    },
+    Stack: {
+      tag: "div",
+      baseClass: "chakra-stack",
+      variants: {
+        horizontal: "chakra-stack--horizontal",
+        vertical: "chakra-stack--vertical"
+      }
+    }
+  }
+};
+var chakraAdapter = componentAdapter(chakraConfig);
+
+// src/ecosystem/ui/material.ts
+var materialConfig = {
+  name: "material",
+  prefix: "mdc",
+  components: {
+    Button: {
+      tag: "button",
+      baseClass: "mdc-button",
+      variants: {
+        raised: "mdc-button--raised",
+        outlined: "mdc-button--outlined",
+        text: "mdc-button--text",
+        unelevated: "mdc-button--unelevated"
+      },
+      sizes: {
+        sm: "mdc-button--dense"
+      },
+      defaultProps: { type: "button" }
+    },
+    Input: {
+      tag: "div",
+      baseClass: "mdc-text-field",
+      variants: {
+        outlined: "mdc-text-field--outlined",
+        filled: "mdc-text-field--filled"
+      }
+    },
+    Card: {
+      tag: "div",
+      baseClass: "mdc-card",
+      variants: {
+        outlined: "mdc-card--outlined",
+        elevated: "mdc-card--elevated"
+      }
+    },
+    Modal: {
+      tag: "div",
+      baseClass: "mdc-dialog",
+      variants: {
+        fullscreen: "mdc-dialog--fullscreen"
+      }
+    },
+    Chip: {
+      tag: "span",
+      baseClass: "mdc-chip",
+      variants: {
+        outlined: "mdc-chip--outlined"
+      }
+    },
+    List: {
+      tag: "ul",
+      baseClass: "mdc-list",
+      variants: {
+        dense: "mdc-list--dense"
+      }
+    },
+    ListItem: {
+      tag: "li",
+      baseClass: "mdc-list-item"
+    }
+  }
+};
+var materialAdapter = componentAdapter(materialConfig);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  antdAdapter,
+  chakraAdapter,
+  componentAdapter,
+  createTheme,
+  materialAdapter,
+  mobXAdapter,
+  reduxAdapter,
+  zustandAdapter
+});