woby/dist/ssr.cjs.js

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

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const setters = require("./setters-CyO2VUT6.cjs");
const create_element_ssr = require("./create_element.ssr-B13vRb_y.cjs");
const merge_style = require("./merge_style-DkxC2kon.cjs");
const fragment = require("./fragment-DZv7GBzl.cjs");
const root = require("./root-D1a_tPqg.cjs");
const template = require("./template-C8XYMS58.cjs");
const wrap_clone_element = require("./wrap_clone_element-C4XivH3I.cjs");
const Dynamic = ({
  component,
  props
  /* , children */
}) => {
  if (setters.isFunction(component) || setters.isFunction(props)) {
    return merge_style.memo(() => {
      return merge_style.resolve(create_element_ssr.createElement(
        setters.get(component, false),
        setters.get(props)
        /* children */
      ));
    });
  } else {
    return create_element_ssr.createElement(
      component,
      props
      /* children */
    );
  }
};
const registry = {};
const h = (type, props, ...children) => create_element_ssr.createElement(registry[type] || type, props, ...children);
const register = (components) => void setters.assign(registry, components);
const html = setters.assign(merge_style.htm.bind(h), { register });
const lazy = (fetcher) => {
  const fetcherOnce = setters.once(fetcher);
  const component = (props) => {
    const resource = merge_style.useResource(fetcherOnce);
    return merge_style.memo(() => {
      return merge_style.useResolved(resource, ({ pending, error, value }) => {
        if (pending) return;
        if (error) throw error;
        const component2 = "default" in value ? value.default : value;
        return merge_style.resolve(create_element_ssr.createElement(component2, props));
      });
    });
  };
  component.preload = () => {
    return new Promise((resolve2, reject) => {
      const resource = merge_style.useResource(fetcherOnce);
      merge_style.useResolved(resource, ({ pending, error }) => {
        if (pending) return;
        if (error) return reject(error);
        return resolve2();
      });
    });
  };
  return component;
};
const setChildReplacementText = (child, childPrev) => {
  if (childPrev.nodeType === 3) {
    childPrev.nodeValue = child;
    return childPrev;
  } else {
    const parent = childPrev.parentElement;
    if (!parent) throw new Error("Invalid child replacement");
    const textNode = setters.createText(child);
    parent.replaceChild(textNode, childPrev);
    return textNode;
  }
};
const setChildStatic = (parent, fragment2, fragmentOnly, child, dynamic, stack) => {
  if (!dynamic && setters.isVoidChild(child)) return;
  const prev = setters.FragmentUtils.getChildren(fragment2);
  const prevIsArray = prev instanceof Array;
  const prevLength = prevIsArray ? prev.length : 1;
  const prevFirst = prevIsArray ? prev[0] : prev;
  const prevLast = prevIsArray ? prev[prevLength - 1] : prev;
  const prevSibling = (prevLast == null ? void 0 : prevLast.nextSibling) || null;
  if (prevLength === 0) {
    const type = typeof child;
    if (type === "string" || type === "number" || type === "bigint") {
      const textNode = setters.createText(child);
      if (!fragmentOnly) {
        parent.appendChild(textNode);
      }
      setters.FragmentUtils.replaceWithNode(fragment2, textNode);
      return;
    } else if (type === "object" && child !== null && typeof child.nodeType === "number") {
      const node = child;
      if (!fragmentOnly) {
        parent.insertBefore(node, null);
      }
      setters.FragmentUtils.replaceWithNode(fragment2, node);
      return;
    }
  }
  if (prevLength === 1) {
    const type = typeof child;
    if (type === "string" || type === "number" || type === "bigint") {
      const node = setChildReplacementText(String(child), prevFirst);
      setters.FragmentUtils.replaceWithNode(fragment2, node);
      return;
    }
  }
  const fragmentNext = setters.FragmentUtils.make();
  const children = Array.isArray(child) ? child : [child];
  for (let i = 0, l = children.length; i < l; i++) {
    const child2 = children[i];
    const type = typeof child2;
    if (type === "string" || type === "number" || type === "bigint") {
      setters.FragmentUtils.pushNode(fragmentNext, setters.createText(child2));
    } else if (type === "object" && child2 !== null && typeof child2.nodeType === "number") {
      setters.FragmentUtils.pushNode(fragmentNext, child2);
    } else if (type === "function") {
      const fragment22 = setters.FragmentUtils.make();
      let childFragmentOnly = !fragmentOnly;
      setters.FragmentUtils.pushFragment(fragmentNext, fragment22);
      setters.resolveChild(child2, (child3, dynamic2, stack2) => {
        const fragmentOnly2 = childFragmentOnly;
        childFragmentOnly = false;
        setChildStatic(parent, fragment22, fragmentOnly2, child3, dynamic2, stack2);
      }, false, stack);
    }
  }
  let next = setters.FragmentUtils.getChildren(fragmentNext);
  let nextLength = fragmentNext.length;
  if (nextLength === 0 && prevLength === 1 && prevFirst.nodeType === 8) {
    return;
  }
  if (!fragmentOnly && (nextLength === 0 || prevLength === 1 && prevFirst.nodeType === 8 || children[setters.SYMBOL_UNCACHED])) {
    const { childNodes } = parent;
    if (childNodes.length === prevLength) {
      parent.textContent = "";
      if (nextLength === 0) {
        const placeholder = setters.createComment("");
        setters.FragmentUtils.pushNode(fragmentNext, placeholder);
        if (next !== fragmentNext.values) {
          next = placeholder;
          nextLength += 1;
        }
      }
      if (prevSibling) {
        if (next instanceof Array) {
          prevSibling.before.apply(prevSibling, next);
        } else {
          parent.insertBefore(next, prevSibling);
        }
      } else {
        if (next instanceof Array) {
          parent.append.apply(parent, next);
        } else {
          parent.append(next);
        }
      }
      setters.FragmentUtils.replaceWithFragment(fragment2, fragmentNext);
      return;
    }
  }
  if (nextLength === 0) {
    const placeholder = setters.createComment("");
    setters.FragmentUtils.pushNode(fragmentNext, placeholder);
    if (next !== fragmentNext.values) {
      next = placeholder;
      nextLength += 1;
    }
  }
  if (!fragmentOnly) {
    setters.diff(parent, prev, next, prevSibling);
  }
  setters.FragmentUtils.replaceWithFragment(fragment2, fragmentNext);
};
const setChild = (parent, child, fragment2 = setters.FragmentUtils.make(), stack) => {
  setters.resolveChild(child, setChildStatic.bind(void 0, parent, fragment2, false), false, stack);
};
const renderToString = (child) => {
  const p = { children: null };
  const stack = new Error();
  setChild(p, child, setters.FragmentUtils.make(), stack);
  return p.children.flat(Infinity).join("");
};
exports.$$ = setters.get;
exports.CONTEXTS_DATA = setters.CONTEXTS_DATA;
exports.DIRECTIVES = setters.DIRECTIVES;
exports.SYMBOLS_DIRECTIVES = setters.SYMBOLS_DIRECTIVES;
exports.SYMBOL_CLONE = setters.SYMBOL_CLONE;
exports.SYMBOL_OBSERVABLE = setters.SYMBOL_OBSERVABLE;
exports.SYMBOL_OBSERVABLE_FROZEN = setters.SYMBOL_OBSERVABLE_FROZEN;
exports.SYMBOL_OBSERVABLE_READABLE = setters.SYMBOL_OBSERVABLE_READABLE;
exports.SYMBOL_OBSERVABLE_WRITABLE = setters.SYMBOL_OBSERVABLE_WRITABLE;
exports.SYMBOL_SUSPENSE = setters.SYMBOL_SUSPENSE$1;
exports.SYMBOL_SUSPENSE_COLLECTOR = setters.SYMBOL_SUSPENSE_COLLECTOR;
exports.SYMBOL_TEMPLATE_ACCESSOR = setters.SYMBOL_TEMPLATE_ACCESSOR;
exports.SYMBOL_UNCACHED = setters.SYMBOL_UNCACHED;
exports.SYMBOL_UNTRACKED = setters.SYMBOL_UNTRACKED;
exports.SYMBOL_UNTRACKED_UNWRAPPED = setters.SYMBOL_UNTRACKED_UNWRAPPED;
exports.isBatching = setters.isBatching;
exports.isObservable = setters.isObservable;
exports.isStore = setters.isStore;
exports.store = setters.store;
exports.untrack = setters.untrack;
exports.useCleanup = setters.cleanup;
exports.useEffect = setters.effect;
exports.useMicrotask = setters.useMicrotask;
exports.createElement = create_element_ssr.createElement;
exports.h = create_element_ssr.createElement;
exports.$ = merge_style.observable;
exports.ErrorBoundary = merge_style.ErrorBoundary;
exports.For = merge_style.For;
exports.If = merge_style.If;
exports.Suspense = merge_style.Suspense;
exports.Switch = merge_style.Switch;
exports.Ternary = merge_style.Ternary;
exports.batch = merge_style.batch;
exports.createContext = merge_style.createContext;
exports.createDirective = merge_style.createDirective;
exports.hmr = merge_style.hmr;
exports.mergeStyles = merge_style.mergeStyles;
exports.resolve = merge_style.resolve;
exports.tick = merge_style.tick;
exports.useAbortController = merge_style.useAbortController;
exports.useAbortSignal = merge_style.useAbortSignal;
exports.useAnimationFrame = merge_style.useAnimationFrame;
exports.useAnimationLoop = merge_style.useAnimationLoop;
exports.useBoolean = merge_style.boolean;
exports.useContext = merge_style.useContext;
exports.useDisposed = merge_style.disposed;
exports.useEventListener = merge_style.useEventListener;
exports.useFetch = merge_style.useFetch;
exports.useIdleCallback = merge_style.useIdleCallback;
exports.useIdleLoop = merge_style.useIdleLoop;
exports.useInterval = merge_style.useInterval;
exports.useMemo = merge_style.memo;
exports.usePromise = merge_style.usePromise;
exports.useReadonly = merge_style.readonly;
exports.useResolved = merge_style.useResolved;
exports.useResource = merge_style.useResource;
exports.useSelector = merge_style.selector;
exports.useSuspended = merge_style.suspended;
exports.useTimeout = merge_style.useTimeout;
exports.useUntracked = merge_style.untracked;
exports.Fragment = fragment.Fragment;
exports.useRoot = root.root;
exports.template = template.template;
exports.wrapCloneElement = wrap_clone_element.wrapCloneElement;
exports.Dynamic = Dynamic;
exports.html = html;
exports.lazy = lazy;
exports.render = renderToString;
exports.renderToString = renderToString;
//# sourceMappingURL=ssr.cjs.js.map