@fluixi/core 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/src/lib/render/index.js

@@ -1,5 +1,4 @@
 /**
- * @fileoverview Client-Side Rendering for Fluixi
  * @module @fluixi/core/render
  *
  * Client-side rendering:
@@ -13,22 +12,17 @@ import { createRoot } from '@fluixi/reactive/signal';
 import { stampVersions, warnOnVersionSkew } from './versions.js';
 import { isDOMNode, delegateEvents, insert, } from '@fluixi/dom';
 // ============================================================================
-// SECTION 7 — RENDERING (CLIENT)
+// RENDERING (CLIENT)
 // ============================================================================
 /**
  * Render a component into a DOM element
  *
- * Section 7 — CLIENT:
+ * On the client:
  * - Real DOM (no Virtual DOM)
  * - Fine-grained mutation (no reconciliation)
  *
- * Section 1: Component executes once during render
- * Section 5: Creates reactive owner (root)
- *
- * @param {() => any} code - Component or function to render
- * @param {HTMLElement} container - Target DOM element
- * @param {RenderOptions} options - Render options
- * @returns {() => void} Dispose function
+ * Component executes once during render
+ * Creates reactive owner (root)
  *
  * @example
  * ```typescript
@@ -55,11 +49,11 @@ export function render(code, container, options = {}) {
     // domRender(code, container)
     createRoot((dispose) => {
         disposer = dispose;
-        // Section 1: Execute code function once — Providers run here with Owner = root
+        // Execute code function once. Providers run here with Owner = root
         // so "also stamp" in createProvider sets context on root.contexts, making
         // it reachable from every render effect created by insert() below.
         const result = typeof code === 'function' ? code() : code;
-        // Section 7: Insert into real DOM using the SAME root as code() so that
+        // Insert into real DOM using the same root as code() so that
         // render effects share the Owner chain with Provider context nodes.
         // Using domRender() would create a second createRoot, severing the chain.
         container.textContent = '';
@@ -68,8 +62,8 @@ export function render(code, container, options = {}) {
         stampVersions(container);
         warnOnVersionSkew();
         // Wrap the (already-computed) result in a STABLE thunk so insert() creates a
-        // top-level render effect. Without this, a static array result — e.g. the
-        // imperative backend's `[createMemo(() => createComponent(App)), " "]` — is
+        // top-level render effect. Without this, a static array result: e.g. the
+        // imperative backend's `[createMemo(() => createComponent(App)), " "]`: is
         // flattened ONCE with no enclosing effect, so the nested memos are read
         // untracked and reactive boundaries deep in the tree (Suspense fallback ->
         // content, Outlet, Show/For) never update. The thunk returns the same result
@@ -99,11 +93,6 @@ function isLitTemplateResult(value) {
 /**
  * Render into a different part of the DOM tree
  *
- * @param {() => any} code - Component to render
- * @param {HTMLElement} target - Target element (outside current tree)
- * @param {RenderOptions} options - Render options
- * @returns {() => void} Dispose function
- *
  * @example
  * ```typescript
  * import { portal } from '@fluixi/core';
@@ -133,9 +122,6 @@ export function portal(code, target, options = {}) {
 // ============================================================================
 /**
  * Check if a value can be rendered
- *
- * @param {any} value - Value to check
- * @returns {boolean} True if renderable
  */
 export function isRenderable(value) {
     if (value == null)

package/dist/src/lib/render/index.mjs

@@ -1 +1,590 @@
-import{isServer as w}from"@fluixi/dom";import{createRoot as Fe}from"@fluixi/reactive/signal";import{registerCoreVersion as U}from"@fluixi/dom";var S="1.0.0-alpha.83";import{stampVersions as k,warnOnVersionSkew as g,versions as He}from"@fluixi/dom";U(S);import{isDOMNode as $e,delegateEvents as _,insert as ze}from"@fluixi/dom";import{isServer as T}from"@fluixi/dom";import{createComponent as V,asComponent as W}from"@fluixi/dom";import{untrack as L,onCleanup as u,getOwner as b,createEffect as l,createMemo as E,createSignal as q,isSignal as H,batch as B,runWithOwner as O,isOwnerDisposed as K}from"@fluixi/reactive/signal";var J={context:null,owner:null};function X(){return J}var h=typeof process<"u"&&!1,y=Symbol.for("fluixi-lifecycle");function R(){let e=b();if(!e)return null;if(!e[y]){let t={mounts:[],effects:[],scheduled:!1};e[y]=t}return e[y]}function P(e){if(e.scheduled)return;if(T()){e.mounts=[],e.effects=[];return}e.scheduled=!0;let t=b();queueMicrotask(()=>{if(K(t)){e.mounts=[],e.effects=[];return}O(t,()=>{for(let o of e.mounts)try{let n=o();typeof n=="function"&&u(n)}catch(n){console.error("Error in onMount callback:",n)}for(let o of e.effects){let n;l(()=>{n&&n(),n=o()}),u(()=>{n&&n()})}e.mounts=[],e.effects=[]})})}function Q(e,t){return V(e,t)}function Y(e,t){let o=typeof e=="function"?L(()=>e(t)):e,n=o!=null&&(typeof o=="function"||typeof o=="object");if(n)try{o.$name=e.name}catch{}return n&&!H(o)?W(o):o}function G(e,t=!0){if(T())return;let o=R();if(o){if(!t){o.scheduled||e();return}o.mounts.push(e),P(o)}else{if(!t){e();return}l(()=>{let n=L(e);typeof n=="function"&&u(n)})}}function Z(e){u(e)}function A(e){let t=R();if(t)t.effects.push(e),P(t);else{let o;l(()=>{o&&o(),o=e()}),u(()=>{o&&o()})}}function ee(e){return E(e)}function ne(e){let t={current:e};return u(()=>{t.current=null}),t}function te(e,t){let[o,n]=q(t);return[o,s=>{n(e(o(),s))}]}function oe(e,t,o,n){A(()=>{let i=e&&"current"in e?e.current:e;if(i)return i.addEventListener(t,o,n),()=>{i.removeEventListener(t,o,n)}})}function re(e){return e}function ie(){return h}function se(e){h&&e()}import{createSignal as x,createMemo as ae,createEffect as ce,createRenderEffect as fe,isSignal as M,readChildren as ue,useContext as de,createContext as pe,createSuspenseBoundary as le,provideSuspense as j}from"@fluixi/reactive/signal";import{asSuspense as me,isComponent as ye,createComponent as D,runWithoutHydration as be}from"@fluixi/dom";function he(e){return typeof window>"u"?!1:typeof Node=="function"&&e instanceof Node?!0:!!(e&&typeof e=="object"&&typeof e.nodeType=="number")}function xe(e){return!e||typeof e!="object"?!1:!!(typeof e._$litType$<"u"||typeof e._$litDirective$<"u"||Array.isArray(e.strings)&&Array.isArray(e.values))}function F(e){return!!(e&&typeof e=="object"&&typeof e.then=="function"||e instanceof Promise)}function ve(e){return!!(e&&typeof e=="object"&&"type"in e&&"props"in e)}var $=pe(void 0,"suspense-list");function v(e){return D(Ce,e)}function Ce(e){let t=le(),o=de($),n=o?o.register(t.inFallback):void 0;function i(f){return f==null||typeof f=="boolean"?null:typeof f=="function"&&ye(f)&&!M(f)?f():f}let s=be(()=>i(e.fallback??null)),r=j(t,()=>ue(()=>e.children)),a=(f,m)=>{if(!(m>8))if(Array.isArray(f))for(let I of f)a(I,m+1);else typeof f=="function"&&M(f)&&a(f(),m+1)};j(t,()=>{fe(()=>a(r,0))});let[c,d]=x(void 0),p=F(r);return p&&(t.increment(),r.then(f=>{d(()=>f),t.decrement()},()=>t.decrement())),ae(()=>(n?n.showFallback():t.inFallback())?s:p?c():r)}function we(e){return D(Se,e)}function Se(e){let{revealOrder:t="together",tail:o}=e,n=[];function i(){if(t==="together"){let r=n.every(a=>!a.inFallback());n.forEach(a=>{a.setShowContent(r),a.setShowFallback(!r)})}else{let r=t==="backwards"?[...n].reverse():n,a=!1;for(let c of r)a||c.inFallback()?(a=!0,c.setShowContent(!1),c.setShowFallback(o!=="hidden")):(c.setShowContent(!0),c.setShowFallback(!1))}}let s={register:r=>{let[a,c]=x(!0),[d,p]=x(!1);return n.push({inFallback:r,setShowContent:c,setShowFallback:p}),ce(()=>{r(),i()}),{showContent:a,showFallback:d}}};return $.Provider({value:s,children:e.children})}me(v);Object.defineProperty(v,"__suspense",{value:!0,enumerable:!0});import{createComponent as ke}from"@fluixi/dom";import{untrack as ge,createMemo as Te,createResource as Le}from"@fluixi/reactive/signal";function z(e){if(e!=null&&(typeof e=="object"||typeof e=="function"))try{e.$lazy=!0}catch{}return e}function C(e,t){let o,n,i;function s(){return n||(n=e().then(a=>o=a.default)),n}t?.preload&&s();let r=(a=>{if(o){let c=o;return z(ge(()=>c(a)))}if(!i){let[c]=Le(()=>s(),{transport:!1});if(i=c,c.error)throw c.error}return Te(()=>{let c=i();return c?z(ke(c,a)):void 0})});return r.preload=()=>s().then(()=>{}),r.$lazy=!0,r.loader=e,r}import{isServer as N}from"@fluixi/dom";import{createMemo as Ee,createSignal as Oe}from"@fluixi/reactive/signal";import{observeIntersection as Re}from"@fluixi/dom/utils";function Pe(e,t){let o=t.export??"default",n=C(()=>e().then(s=>{let r=s[o];if(typeof r!="function")throw new Error(`deferred(): module has no '${o}' export (got ${typeof r}).`);return{default:r}}),{fallback:t.fallback});function i(s){if(t.strategy.kind==="never")return N()?n(s):null;if(N()||t.strategy.kind==="eager")return n(s);let[r,a]=Oe(!1),c=()=>{n.preload().then(()=>a(!0))},d=t.strategy.kind==="visible"?Ae():void 0;return Me(t.strategy,c,d),Ee(()=>r()?n(s):d??t.fallback??null,void 0,{name:"deferred"})}return i.preload=n.preload,i}function Ae(){let e=document.createElement("span");return e.setAttribute("data-fx-load","visible"),e.style.display="block",e}function Me(e,t,o){let n=!1,i=()=>{n||(n=!0,t())};switch(e.kind){case"idle":{let s=globalThis.requestIdleCallback;s?s(i):setTimeout(i,1);return}case"visible":{if(!o||typeof IntersectionObserver>"u"){i();return}let s=Re(o,r=>{r&&(s(),i())},{rootMargin:e.rootMargin??"0px"});return}case"interaction":{let s=()=>{for(let r of e.events)document.removeEventListener(r,s,!0);i()};for(let r of e.events)document.addEventListener(r,s,{capture:!0,passive:!0});return}case"media":{if(typeof matchMedia>"u"){i();return}let s=matchMedia(e.query);if(s.matches){i();return}let r=a=>{a.matches&&(s.removeEventListener("change",r),i())};s.addEventListener("change",r);return}default:i()}}import{createResource as je}from"@fluixi/reactive/signal";function De(e){let t=()=>{let n=e.value;return typeof n=="function"?n():n},[o]=je(t);return()=>{if(o.loading)return e.fallback;let n=e.children;return typeof n=="function"?n(o()):n}}function Ne(e,t,o={}){if(_(["click","input","change","submit"]),w())throw new Error("render() is for client-side only. Use renderToString() on server.");if(!t)throw new Error("Container element is required");let n;return Fe(i=>{n=i;let s=typeof e=="function"?e():e;t.textContent="",k(t),g(),ze(t,()=>s)}),()=>{n&&(n(),n=void 0)}}function _e(e){return e&&typeof e=="object"&&(e._$litType$!==void 0||e._$litDirective$!==void 0)}function En(e,t,o={}){let n=document.createElement("div");n.setAttribute("data-portal","true"),t.appendChild(n);let i=Ne(e,n,o);return()=>{i(),t.contains(n)&&t.removeChild(n)}}function On(e){return!!(e==null||typeof e=="function"||$e(e)||_e(e)||Array.isArray(e)||typeof e=="string"||typeof e=="number"||typeof e=="boolean")}function Rn(){w()||_(["click","input","change","submit"])}function Pn(){w()}export{Y as $component,De as Await,h as DEV,v as Suspense,we as SuspenseList,B as batch,Pn as cleanupDelegation,Q as createComponent,l as createEffect,E as createMemo,Pe as deferred,se as devOnly,b as getOwner,X as getSharedConfig,Rn as initDelegation,ie as isDev,ve as isJSXElement,xe as isLitResult,he as isNode,F as isPromise,On as isRenderable,C as lazy,u as onCleanup,G as onMount,Z as onUnmount,En as portal,Ne as render,O as runWithOwner,re as useCallback,A as useEffect,oe as useEventListener,ee as useMemo,te as useReducer,ne as useRef};
+// src/lib/render/index.ts
+import { isServer as isServer3 } from "@fluixi/dom";
+import { createRoot as createRoot2 } from "@fluixi/reactive/signal";
+
+// src/lib/render/versions.ts
+import { registerCoreVersion } from "@fluixi/dom";
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/render/versions.ts
+import { stampVersions, warnOnVersionSkew, versions } from "@fluixi/dom";
+registerCoreVersion(VERSION);
+
+// src/lib/render/index.ts
+import {
+  isDOMNode,
+  delegateEvents,
+  insert
+} from "@fluixi/dom";
+
+// src/lib/render/component.ts
+import { isServer } from "@fluixi/dom";
+import {
+  createComponent as domCreateComponent,
+  asComponent
+} from "@fluixi/dom";
+import {
+  untrack,
+  onCleanup,
+  getOwner,
+  createEffect,
+  createMemo,
+  createSignal,
+  isSignal,
+  batch,
+  runWithOwner,
+  isOwnerDisposed
+} from "@fluixi/reactive/signal";
+var sharedConfig = {
+  context: null,
+  owner: null
+};
+function getSharedConfig() {
+  return sharedConfig;
+}
+var DEV = typeof process !== "undefined" && false;
+var _LIFECYCLE = /* @__PURE__ */ Symbol.for("fluixi-lifecycle");
+function getOwnerLifecycle() {
+  const owner = getOwner();
+  if (!owner) return null;
+  if (!owner[_LIFECYCLE]) {
+    const lc = { mounts: [], effects: [], scheduled: false };
+    owner[_LIFECYCLE] = lc;
+  }
+  return owner[_LIFECYCLE];
+}
+function scheduleLifecycleFlush(lc) {
+  if (lc.scheduled) return;
+  if (isServer()) {
+    lc.mounts = [];
+    lc.effects = [];
+    return;
+  }
+  lc.scheduled = true;
+  const owner = getOwner();
+  queueMicrotask(() => {
+    if (isOwnerDisposed(owner)) {
+      lc.mounts = [];
+      lc.effects = [];
+      return;
+    }
+    runWithOwner(owner, () => {
+      for (const cb of lc.mounts) {
+        try {
+          const cleanup = cb();
+          if (typeof cleanup === "function") {
+            onCleanup(cleanup);
+          }
+        } catch (e) {
+          console.error("Error in onMount callback:", e);
+        }
+      }
+      for (const cb of lc.effects) {
+        let cleanup;
+        createEffect(() => {
+          if (cleanup) cleanup();
+          cleanup = cb();
+        });
+        onCleanup(() => {
+          if (cleanup) cleanup();
+        });
+      }
+      lc.mounts = [];
+      lc.effects = [];
+    });
+  });
+}
+function createComponent(Comp, props) {
+  return domCreateComponent(Comp, props);
+}
+function $component(value, props) {
+  const component = typeof value === "function" ? untrack(() => value(props)) : value;
+  const nameable = component != null && (typeof component === "function" || typeof component === "object");
+  if (nameable) {
+    try {
+      component["$name"] = value.name;
+    } catch {
+    }
+  }
+  if (nameable && !isSignal(component)) {
+    return asComponent(component);
+  }
+  return component;
+}
+function onMount(fn, reactive = true) {
+  if (isServer()) return;
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    if (!reactive) {
+      if (!lc.scheduled) {
+        fn();
+      }
+      return;
+    }
+    lc.mounts.push(fn);
+    scheduleLifecycleFlush(lc);
+  } else {
+    if (!reactive) {
+      fn();
+      return;
+    }
+    createEffect(() => {
+      const cleanup = untrack(fn);
+      if (typeof cleanup === "function") {
+        onCleanup(cleanup);
+      }
+    });
+  }
+}
+function onUnmount(fn) {
+  onCleanup(fn);
+}
+function useEffect(callback) {
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    lc.effects.push(callback);
+    scheduleLifecycleFlush(lc);
+  } else {
+    let cleanup;
+    createEffect(() => {
+      if (cleanup) cleanup();
+      cleanup = callback();
+    });
+    onCleanup(() => {
+      if (cleanup) cleanup();
+    });
+  }
+}
+function useMemo(fn) {
+  return createMemo(fn);
+}
+function useRef(initialValue) {
+  const ref = { current: initialValue };
+  onCleanup(() => {
+    ref.current = null;
+  });
+  return ref;
+}
+function useReducer(reducer, initialState) {
+  const [state, setState] = createSignal(initialState);
+  const dispatch = (action) => {
+    setState(reducer(state(), action));
+  };
+  return [state, dispatch];
+}
+function useEventListener(target, event, handler, options) {
+  useEffect(() => {
+    const element = target && "current" in target ? target.current : target;
+    if (!element) return;
+    element.addEventListener(event, handler, options);
+    return () => {
+      element.removeEventListener(event, handler, options);
+    };
+  });
+}
+function useCallback(callback) {
+  return callback;
+}
+function isDev() {
+  return DEV;
+}
+function devOnly(fn) {
+  if (DEV) {
+    fn();
+  }
+}
+
+// src/lib/render/suspense.ts
+import {
+  createSignal as createSignal2,
+  createMemo as createMemo2,
+  createEffect as createEffect2,
+  createRenderEffect as createRenderEffect2,
+  isSignal as isSignal2,
+  readChildren,
+  useContext as useContext2,
+  createContext as createContext2,
+  createSuspenseBoundary,
+  provideSuspense
+} from "@fluixi/reactive/signal";
+import {
+  asSuspense,
+  isComponent,
+  createComponent as createComponent2,
+  runWithoutHydration
+} from "@fluixi/dom";
+function isNode(value) {
+  if (typeof window === "undefined") return false;
+  if (typeof Node === "function" && value instanceof Node) return true;
+  return !!(value && typeof value === "object" && typeof value.nodeType === "number");
+}
+function isLitResult(value) {
+  if (!value || typeof value !== "object") return false;
+  return !!(typeof value["_$litType$"] !== "undefined" || typeof value["_$litDirective$"] !== "undefined" || Array.isArray(value.strings) && Array.isArray(value.values));
+}
+function isPromise(value) {
+  return !!(value && typeof value === "object" && typeof value.then === "function" || value instanceof Promise);
+}
+function isJSXElement(value) {
+  return !!(value && typeof value === "object" && "type" in value && "props" in value);
+}
+var SuspenseListContext = createContext2(void 0, "suspense-list");
+function Suspense(props) {
+  return createComponent2(SuspenseImpl, props);
+}
+function SuspenseImpl(props) {
+  const boundary = createSuspenseBoundary();
+  const listCtx = useContext2(SuspenseListContext);
+  const listState = listCtx ? listCtx.register(boundary.inFallback) : void 0;
+  function instantiateOnce(val) {
+    if (val == null || typeof val === "boolean") return null;
+    if (typeof val === "function" && isComponent(val) && !isSignal2(val)) return val();
+    return val;
+  }
+  const fallback = runWithoutHydration(() => instantiateOnce(props.fallback ?? null));
+  const children = provideSuspense(boundary, () => readChildren(() => props.children));
+  const track = (value, depth) => {
+    if (depth > 8) return;
+    if (Array.isArray(value)) {
+      for (const x of value) track(x, depth + 1);
+    } else if (typeof value === "function" && isSignal2(value)) {
+      track(value(), depth + 1);
+    }
+  };
+  provideSuspense(boundary, () => {
+    createRenderEffect2(() => track(children, 0));
+  });
+  const [resolved, setResolved] = createSignal2(void 0);
+  const childIsPromise = isPromise(children);
+  if (childIsPromise) {
+    boundary.increment();
+    children.then(
+      (v) => {
+        setResolved(() => v);
+        boundary.decrement();
+      },
+      () => boundary.decrement()
+    );
+  }
+  return createMemo2(() => {
+    const showFallback = listState ? listState.showFallback() : boundary.inFallback();
+    if (showFallback) return fallback;
+    if (childIsPromise) return resolved();
+    return children;
+  });
+}
+function SuspenseList(props) {
+  return createComponent2(SuspenseListImpl, props);
+}
+function SuspenseListImpl(props) {
+  const { revealOrder = "together", tail } = props;
+  const registrations = [];
+  function coordinateReveal() {
+    if (revealOrder === "together") {
+      const allResolved = registrations.every((r) => !r.inFallback());
+      registrations.forEach((r) => {
+        r.setShowContent(allResolved);
+        r.setShowFallback(!allResolved);
+      });
+    } else {
+      const items = revealOrder === "backwards" ? [...registrations].reverse() : registrations;
+      let blocked = false;
+      for (const r of items) {
+        if (blocked || r.inFallback()) {
+          blocked = true;
+          r.setShowContent(false);
+          r.setShowFallback(tail !== "hidden");
+        } else {
+          r.setShowContent(true);
+          r.setShowFallback(false);
+        }
+      }
+    }
+  }
+  const coordinator = {
+    register: (inFallback) => {
+      const [showContent, setShowContent] = createSignal2(true);
+      const [showFallback, setShowFallback] = createSignal2(false);
+      registrations.push({ inFallback, setShowContent, setShowFallback });
+      createEffect2(() => {
+        inFallback();
+        coordinateReveal();
+      });
+      return { showContent, showFallback };
+    }
+  };
+  return SuspenseListContext.Provider({
+    value: coordinator,
+    children: props.children
+  });
+}
+asSuspense(Suspense);
+Object.defineProperty(Suspense, "__suspense", { value: true, enumerable: true });
+
+// src/lib/render/lazy.ts
+import { createComponent as createComponent3 } from "@fluixi/dom";
+import {
+  untrack as untrack2,
+  createMemo as createMemo3,
+  createResource as createResource2
+} from "@fluixi/reactive/signal";
+function fromChunk(value) {
+  if (value != null && (typeof value === "object" || typeof value === "function")) {
+    try {
+      value["$lazy"] = true;
+    } catch {
+    }
+  }
+  return value;
+}
+function lazy(loader, options) {
+  let resolved;
+  let promise;
+  let component;
+  function load() {
+    if (!promise) {
+      promise = loader().then((mod) => resolved = mod.default);
+    }
+    return promise;
+  }
+  if (options?.preload) load();
+  const LazyWrapper = ((props) => {
+    if (resolved) {
+      const C = resolved;
+      return fromChunk(untrack2(() => C(props)));
+    }
+    if (!component) {
+      const [resource] = createResource2(() => load(), { transport: false });
+      component = resource;
+      if (resource.error) throw resource.error;
+    }
+    return createMemo3(() => {
+      const C = component();
+      return C ? fromChunk(createComponent3(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/render/deferred.ts
+import { isServer as isServer2 } from "@fluixi/dom";
+import { createMemo as createMemo4, createSignal as createSignal3 } from "@fluixi/reactive/signal";
+import { observeIntersection } from "@fluixi/dom/utils";
+function deferred(loader, options) {
+  const exportName = options.export ?? "default";
+  const Lazy = lazy(
+    () => loader().then((mod) => {
+      const component = mod[exportName];
+      if (typeof component !== "function") {
+        throw new Error(
+          `deferred(): module has no '${exportName}' export (got ${typeof component}).`
+        );
+      }
+      return { default: component };
+    }),
+    { fallback: options.fallback }
+  );
+  function Deferred(props) {
+    if (options.strategy.kind === "never") return isServer2() ? Lazy(props) : null;
+    if (isServer2() || options.strategy.kind === "eager") return Lazy(props);
+    const [ready, setReady] = createSignal3(false);
+    const start = () => {
+      void Lazy.preload().then(() => setReady(true));
+    };
+    const anchor = options.strategy.kind === "visible" ? createAnchor() : void 0;
+    schedule(options.strategy, start, anchor);
+    return createMemo4(() => ready() ? Lazy(props) : anchor ?? options.fallback ?? null, void 0, {
+      name: "deferred"
+    });
+  }
+  Deferred.preload = Lazy.preload;
+  return Deferred;
+}
+function createAnchor() {
+  const el = document.createElement("span");
+  el.setAttribute("data-fx-load", "visible");
+  el.style.display = "block";
+  return el;
+}
+function schedule(strategy, start, anchor) {
+  let fired = false;
+  const once = () => {
+    if (fired) return;
+    fired = true;
+    start();
+  };
+  switch (strategy.kind) {
+    case "idle": {
+      const ric = globalThis.requestIdleCallback;
+      if (ric) ric(once);
+      else setTimeout(once, 1);
+      return;
+    }
+    case "visible": {
+      if (!anchor || typeof IntersectionObserver === "undefined") {
+        once();
+        return;
+      }
+      const stop = observeIntersection(
+        anchor,
+        (isIntersecting) => {
+          if (!isIntersecting) return;
+          stop();
+          once();
+        },
+        { rootMargin: strategy.rootMargin ?? "0px" }
+      );
+      return;
+    }
+    case "interaction": {
+      const handler = () => {
+        for (const event of strategy.events) {
+          document.removeEventListener(event, handler, true);
+        }
+        once();
+      };
+      for (const event of strategy.events) {
+        document.addEventListener(event, handler, { capture: true, passive: true });
+      }
+      return;
+    }
+    case "media": {
+      if (typeof matchMedia === "undefined") {
+        once();
+        return;
+      }
+      const query = matchMedia(strategy.query);
+      if (query.matches) {
+        once();
+        return;
+      }
+      const onChange = (e) => {
+        if (!e.matches) return;
+        query.removeEventListener("change", onChange);
+        once();
+      };
+      query.addEventListener("change", onChange);
+      return;
+    }
+    /* c8 ignore next 3 */
+    default:
+      once();
+  }
+}
+
+// src/lib/render/await.ts
+import { createResource as createResource3 } from "@fluixi/reactive/signal";
+function Await(props) {
+  const fetcher = () => {
+    const v = props.value;
+    return typeof v === "function" ? v() : v;
+  };
+  const [data] = createResource3(fetcher);
+  return () => {
+    if (data.loading) return props.fallback;
+    const child = props.children;
+    return typeof child === "function" ? child(data()) : child;
+  };
+}
+
+// src/lib/render/index.ts
+function render(code, container, options = {}) {
+  delegateEvents(["click", "input", "change", "submit"]);
+  if (isServer3()) {
+    throw new Error(
+      "render() is for client-side only. Use renderToString() on server."
+    );
+  }
+  if (!container) {
+    throw new Error("Container element is required");
+  }
+  let disposer;
+  createRoot2((dispose) => {
+    disposer = dispose;
+    const result = typeof code === "function" ? code() : code;
+    container.textContent = "";
+    stampVersions(container);
+    warnOnVersionSkew();
+    insert(container, () => result);
+  });
+  return () => {
+    if (disposer) {
+      disposer();
+      disposer = void 0;
+    }
+  };
+}
+function isLitTemplateResult(value) {
+  return value && typeof value === "object" && (value["_$litType$"] !== void 0 || value["_$litDirective$"] !== void 0);
+}
+function portal(code, target, options = {}) {
+  const container = document.createElement("div");
+  container.setAttribute("data-portal", "true");
+  target.appendChild(container);
+  const dispose = render(code, container, options);
+  return () => {
+    dispose();
+    if (target.contains(container)) {
+      target.removeChild(container);
+    }
+  };
+}
+function isRenderable(value) {
+  if (value == null) return true;
+  if (typeof value === "function") return true;
+  if (isDOMNode(value)) return true;
+  if (isLitTemplateResult(value)) return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  return false;
+}
+function initDelegation() {
+  if (isServer3()) return;
+  delegateEvents(["click", "input", "change", "submit"]);
+}
+function cleanupDelegation() {
+  if (isServer3()) return;
+}
+export {
+  $component,
+  Await,
+  DEV,
+  Suspense,
+  SuspenseList,
+  batch,
+  cleanupDelegation,
+  createComponent,
+  createEffect,
+  createMemo,
+  deferred,
+  devOnly,
+  getOwner,
+  getSharedConfig,
+  initDelegation,
+  isDev,
+  isJSXElement,
+  isLitResult,
+  isNode,
+  isPromise,
+  isRenderable,
+  lazy,
+  onCleanup,
+  onMount,
+  onUnmount,
+  portal,
+  render,
+  runWithOwner,
+  useCallback,
+  useEffect,
+  useEventListener,
+  useMemo,
+  useReducer,
+  useRef
+};