woby/dist/index.es.js

A high-performance framework with fine-grained observable/signal-based reactivity for building rich applications.

var _a, _b;
import { c as createElement } from "./runtime-DHiCLtGC.js";
import { g, j, a, j as j2 } from "./runtime-DHiCLtGC.js";
import { i as isFunction, E as get, a5 as _with, R as cleanup, a6 as isPrimitive, S as SYMBOL_CLONE, n as isObject, a7 as isArray, h as assign, K as once, Y as SYMBOL_OBSERVABLE } from "./setters-Ddu0s6oK.js";
import { a1, D, a2, F, a4, Z, _, a0, a3, I, l, N, $, w, x, C, ab, ac, aJ, P, aI, t, r, M, a9, ad, j as j3, U, ae, af, ag, ah, ai, aj, p, V, ak, a8, al, o, W, k, am, an, q, ao, aG, L, aF, aH, g as g2, ap, m, f, aq, ar, as, au, av, at, e, aw, d, ax, c, ay, aE, b, az, v, a as a5, aB, aA, s, aC, aD, X, aa, u, J, T } from "./setters-Ddu0s6oK.js";
import { m as memo, r as resolve, a as useResolved, o as observable, H as suspense, h as htm, u as useResource } from "./merge_style-CyMhMoCQ.js";
import { E, F as F2, I as I2, S, c as c2, T as T2, z, A, B, C as C2, J as J2, G, D as D2, d as d2, e as e2, f as f2, g as g3, b as b2, i, j as j4, k as k2, l as l2, n, p as p2, q as q2, s as s2, t as t2, v as v2, w as w2, x as x2, y } from "./merge_style-CyMhMoCQ.js";
import { r as root } from "./root-B8Ruf358.js";
import { F as F3 } from "./fragment-CrJfXftf.js";
import { P as P2, r as r2, a as a6 } from "./render_to_string-DPtjoKMd.js";
import { t as t3 } from "./template-C8ap5u3t.js";
import { w as wrapCloneElement } from "./wrap_clone_element-CPcdGL7P.js";
import { S as S2 } from "./wrap_clone_element-CPcdGL7P.js";
const IS_BROWSER = !!((_b = (_a = globalThis.CDATASection) == null ? void 0 : _a.toString) == null ? void 0 : _b.call(_a).match(/^\s*function\s+CDATASection\s*\(\s*\)\s*\{\s*\[native code\]\s*\}\s*$/));
const isServer = () => {
  return !IS_BROWSER;
};
const Dynamic = ({ component, props, children }) => {
  if (isFunction(component) || isFunction(props)) {
    return memo(() => {
      return resolve(createElement(get(component, false), get(props), children));
    });
  } else {
    return createElement(component, props, children);
  }
};
const cache = {};
const runWithSuperRoot = _with();
let lockId = 1;
const KeepAlive = ({ id, ttl, children }) => {
  return memo((stack) => {
    return useResolved([id, ttl], (id2, ttl2) => {
      var _a2;
      const lock = lockId++;
      const item = cache[id2] || (cache[id2] = { id: id2, lock });
      item.lock = lock;
      (_a2 = item.reset) == null ? void 0 : _a2.call(item, stack);
      item.suspended || (item.suspended = observable(false));
      item.suspended(false);
      if (!item.dispose || !item.result) {
        runWithSuperRoot(() => {
          root((stack2, dispose) => {
            item.dispose = () => {
              delete cache[id2];
              dispose(stack2);
            };
            suspense(item.suspended, () => {
              item.result = resolve(children);
            }, stack2);
          });
        }, stack);
      }
      cleanup(() => {
        var _a3;
        const hasLock = () => lock === item.lock;
        if (!hasLock()) return;
        (_a3 = item.suspended) == null ? void 0 : _a3.call(item, true);
        if (!ttl2 || ttl2 <= 0 || ttl2 >= Infinity) return;
        const dispose = () => {
          var _a4;
          return hasLock() && ((_a4 = item.dispose) == null ? void 0 : _a4.call(item, stack));
        };
        const timeoutId = setTimeout(dispose, ttl2);
        const reset = () => clearTimeout(timeoutId);
        item.reset = reset;
      });
      return item.result;
    });
  });
};
const types = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null
}, Symbol.toStringTag, { value: "Module" }));
const cloneElement = (element, props, ...children) => {
  if (isPrimitive(element))
    return element;
  else if (isFunction(element)) {
    if (!element[SYMBOL_CLONE])
      throw new Error("target is not cloneable, it is not created by jsx.createElement");
    const { Component, props: oldProps } = element[SYMBOL_CLONE];
    const newProps = { ...oldProps, ...props };
    if (children.length > 0)
      Object.assign(props, { children });
    return wrapCloneElement(createElement(Component, newProps), Component, newProps);
  } else if (Array.isArray(element))
    return element.map((e3) => cloneElement(e3, props));
  else if (element.cloneNode)
    return element.cloneNode();
  throw new Error("Unknown element");
};
function h$1(component, props, ...children) {
  if (children.length || isObject(props) && !isArray(props)) {
    if (!props) props = { children };
    else props = { ...props, children };
    return createElement(component, props);
  } else {
    return createElement(component, null, props);
  }
}
const registry = {};
const h = (type, props, ...children) => createElement(registry[type] || type, props, ...children);
const register = (components) => void assign(registry, components);
const html = assign(htm.bind(h), { register });
const lazy = (fetcher) => {
  const fetcherOnce = once(fetcher);
  const component = (props) => {
    const resource = useResource(fetcherOnce);
    return memo(() => {
      return useResolved(resource, ({ pending, error, value }) => {
        if (pending) return;
        if (error) throw error;
        const component2 = "default" in value ? value.default : value;
        return resolve(createElement(component2, props));
      });
    });
  };
  component.preload = () => {
    return new Promise((resolve2, reject) => {
      const resource = useResource(fetcherOnce);
      useResolved(resource, ({ pending, error }) => {
        if (pending) return;
        if (error) return reject(error);
        return resolve2();
      });
    });
  };
  return component;
};
const ObservableSymbol = SYMBOL_OBSERVABLE;
export {
  observable as $,
  get as $$,
  a1 as CONTEXTS_DATA,
  D as DEBUGGER,
  a2 as DIRECTIVES,
  Dynamic,
  E as ErrorBoundary,
  F2 as For,
  F3 as Fragment,
  F as FragmentUtils,
  I2 as If,
  types as JSX,
  KeepAlive,
  ObservableSymbol,
  P2 as Portal,
  a4 as SYMBOLS_DIRECTIVES,
  SYMBOL_CLONE,
  SYMBOL_OBSERVABLE,
  Z as SYMBOL_OBSERVABLE_FROZEN,
  _ as SYMBOL_OBSERVABLE_READABLE,
  a0 as SYMBOL_OBSERVABLE_WRITABLE,
  S2 as SYMBOL_STACK,
  a3 as SYMBOL_SUSPENSE,
  I as SYMBOL_SUSPENSE_COLLECTOR,
  l as SYMBOL_TEMPLATE_ACCESSOR,
  N as SYMBOL_UNCACHED,
  $ as SYMBOL_UNTRACKED,
  w as SYMBOL_UNTRACKED_UNWRAPPED,
  x as Stack,
  S as Suspense,
  c2 as Switch,
  T2 as Ternary,
  assign,
  z as batch,
  C as callStack,
  ab as castArray,
  ac as castError,
  aJ as classesToggle,
  cloneElement,
  P as createComment,
  A as createContext,
  B as createDirective,
  aI as createDocumentFragment,
  createElement,
  t as createHTMLNode,
  r as createSVGNode,
  M as createText,
  a9 as fixBigInt,
  ad as flatten,
  g as getMeta,
  h$1 as h,
  C2 as hmr,
  html,
  j3 as indexOf,
  isArray,
  U as isBatching,
  ae as isBoolean,
  af as isComponent,
  ag as isError,
  ah as isFalsy,
  isFunction,
  ai as isFunctionReactive,
  aj as isNil,
  p as isNode,
  isObject,
  V as isObservable,
  J2 as isObservableWritable,
  isPrimitive,
  ak as isPromise,
  a8 as isProxy,
  al as isSVG,
  o as isSVGElement,
  isServer,
  W as isStore,
  k as isString,
  am as isTemplateAccessor,
  an as isTruthy,
  q as isVoidChild,
  j as jsx,
  a as jsxDEV,
  j2 as jsxs,
  lazy,
  G as mergeStyles,
  ao as noop,
  once,
  r2 as render,
  a6 as renderToString,
  resolve,
  aG as resolveArraysAndStatics,
  L as resolveChild,
  aF as resolveClass,
  aH as resolveStyle,
  g2 as setAttribute,
  ap as setAttributeStatic,
  m as setChild,
  f as setChildReplacement,
  aq as setChildReplacementFunction,
  ar as setChildReplacementText,
  as as setChildStatic,
  au as setClass,
  av as setClassBooleanStatic,
  at as setClassStatic,
  e as setClasses,
  aw as setClassesStatic,
  d as setEvent,
  ax as setEventStatic,
  c as setHTML,
  ay as setHTMLStatic,
  aE as setProp,
  b as setProperty,
  az as setPropertyStatic,
  v as setProps,
  a5 as setRef,
  aB as setStyle,
  aA as setStyleStatic,
  s as setStyles,
  aC as setStylesStatic,
  aD as setTemplateAccessor,
  X as store,
  t3 as template,
  D2 as tick,
  aa as toArray,
  u as untrack,
  d2 as useAbortController,
  e2 as useAbortSignal,
  f2 as useAnimationFrame,
  g3 as useAnimationLoop,
  b2 as useBoolean,
  cleanup as useCleanup,
  i as useContext,
  j4 as useDisposed,
  J as useEffect,
  k2 as useEventListener,
  l2 as useFetch,
  n as useIdleCallback,
  p2 as useIdleLoop,
  q2 as useInterval,
  memo as useMemo,
  T as useMicrotask,
  s2 as usePromise,
  t2 as useReadonly,
  useResolved,
  useResource,
  root as useRoot,
  v2 as useSelector,
  w2 as useSuspended,
  x2 as useTimeout,
  y as useUntracked,
  wrapCloneElement
};
//# sourceMappingURL=index.es.js.map