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

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

@@ -1 +1,214 @@
-import{isServer as a}from"@fluixi/dom";import{createComponent as y,asComponent as x}from"@fluixi/dom";import{untrack as p,onCleanup as r,getOwner as f,createEffect as s,createMemo as C,createSignal as T,isSignal as E,batch as U,runWithOwner as O,isOwnerDisposed as w}from"@fluixi/reactive/signal";var c={context:null,owner:null};function V(){return c}function F(e){c.owner=e,c.context=e}function I(){return c.context||c.owner}var d=typeof process<"u"&&!1,u=Symbol.for("fluixi-lifecycle");function l(){let e=f();if(!e)return null;if(!e[u]){let t={mounts:[],effects:[],scheduled:!1};e[u]=t}return e[u]}function v(e){if(e.scheduled)return;if(a()){e.mounts=[],e.effects=[];return}e.scheduled=!0;let t=f();queueMicrotask(()=>{if(w(t)){e.mounts=[],e.effects=[];return}O(t,()=>{for(let n of e.mounts)try{let o=n();typeof o=="function"&&r(o)}catch(o){console.error("Error in onMount callback:",o)}for(let n of e.effects){let o;s(()=>{o&&o(),o=n()}),r(()=>{o&&o()})}e.mounts=[],e.effects=[]})})}function N(e){}function $(e,t){return y(e,t)}function q(e,t){let n=typeof e=="function"?p(()=>e(t)):e,o=n!=null&&(typeof n=="function"||typeof n=="object");if(o)try{n.$name=e.name}catch{}return o&&!E(n)?x(n):n}function P(e,t=!0){if(a())return;let n=l();if(n){if(!t){n.scheduled||e();return}n.mounts.push(e),v(n)}else{if(!t){e();return}s(()=>{let o=p(e);typeof o=="function"&&r(o)})}}function Y(e){r(e)}function h(e){let t=l();if(t)t.effects.push(e),v(t);else{let n;s(()=>{n&&n(),n=e()}),r(()=>{n&&n()})}}function z(e){return C(e)}function B(e){let t={current:e};return r(()=>{t.current=null}),t}function G(e,t){let[n,o]=T(t);return[n,m=>{o(e(n(),m))}]}function H(e,t,n,o){h(()=>{let i=e&&"current"in e?e.current:e;if(i)return i.addEventListener(t,n,o),()=>{i.removeEventListener(t,n,o)}})}function J(e){return e}function Q(){return f()!==null}function X(){return d}function Z(e){d&&e()}export{q as $component,d as DEV,U as batch,$ as createComponent,s as createEffect,C as createMemo,Z as devOnly,N as ensureIntegration,I as getContextOwner,f as getOwner,V as getSharedConfig,Q as hasLifecycleContext,X as isDev,r as onCleanup,P as onMount,Y as onUnmount,O as runWithOwner,F as setOwner,J as useCallback,h as useEffect,H as useEventListener,z as useMemo,G as useReducer,B as useRef};
+// 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;
+}
+function setOwner(owner) {
+  sharedConfig.owner = owner;
+  sharedConfig.context = owner;
+}
+function getContextOwner() {
+  return sharedConfig.context || sharedConfig.owner;
+}
+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 ensureIntegration(_from) {
+}
+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 hasLifecycleContext() {
+  return getOwner() !== null;
+}
+function isDev() {
+  return DEV;
+}
+function devOnly(fn) {
+  if (DEV) {
+    fn();
+  }
+}
+export {
+  $component,
+  DEV,
+  batch,
+  createComponent,
+  createEffect,
+  createMemo,
+  devOnly,
+  ensureIntegration,
+  getContextOwner,
+  getOwner,
+  getSharedConfig,
+  hasLifecycleContext,
+  isDev,
+  onCleanup,
+  onMount,
+  onUnmount,
+  runWithOwner,
+  setOwner,
+  useCallback,
+  useEffect,
+  useEventListener,
+  useMemo,
+  useReducer,
+  useRef
+};

package/dist/src/lib/render/deferred.cjs

@@ -1 +1,175 @@
-"use strict";var f=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var h=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var C=(e,t)=>{for(var a in t)f(e,a,{get:t[a],enumerable:!0})},L=(e,t,a,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of h(t))!b.call(e,n)&&n!==a&&f(e,n,{get:()=>t[n],enumerable:!(i=g(t,n))||i.enumerable});return e};var x=e=>L(f({},"__esModule",{value:!0}),e);var M={};C(M,{deferred:()=>P});module.exports=x(M);var l=require("@fluixi/dom"),u=require("@fluixi/reactive/signal"),k=require("@fluixi/dom/utils");var y=require("@fluixi/dom"),c=require("@fluixi/reactive/signal");function p(e){if(e!=null&&(typeof e=="object"||typeof e=="function"))try{e.$lazy=!0}catch{}return e}function v(e,t){let a,i,n;function r(){return i||(i=e().then(s=>a=s.default)),i}t?.preload&&r();let o=(s=>{if(a){let d=a;return p((0,c.untrack)(()=>d(s)))}if(!n){let[d]=(0,c.createResource)(()=>r(),{transport:!1});if(n=d,d.error)throw d.error}return(0,c.createMemo)(()=>{let d=n();return d?p((0,y.createComponent)(d,s)):void 0})});return o.preload=()=>r().then(()=>{}),o.$lazy=!0,o.loader=e,o}function P(e,t){let a=t.export??"default",i=v(()=>e().then(r=>{let o=r[a];if(typeof o!="function")throw new Error(`deferred(): module has no '${a}' export (got ${typeof o}).`);return{default:o}}),{fallback:t.fallback});function n(r){if(t.strategy.kind==="never")return(0,l.isServer)()?i(r):null;if((0,l.isServer)()||t.strategy.kind==="eager")return i(r);let[o,s]=(0,u.createSignal)(!1),d=()=>{i.preload().then(()=>s(!0))},m=t.strategy.kind==="visible"?T():void 0;return w(t.strategy,d,m),(0,u.createMemo)(()=>o()?i(r):m??t.fallback??null,void 0,{name:"deferred"})}return n.preload=i.preload,n}function T(){let e=document.createElement("span");return e.setAttribute("data-fx-load","visible"),e.style.display="block",e}function w(e,t,a){let i=!1,n=()=>{i||(i=!0,t())};switch(e.kind){case"idle":{let r=globalThis.requestIdleCallback;r?r(n):setTimeout(n,1);return}case"visible":{if(!a||typeof IntersectionObserver>"u"){n();return}let r=(0,k.observeIntersection)(a,o=>{o&&(r(),n())},{rootMargin:e.rootMargin??"0px"});return}case"interaction":{let r=()=>{for(let o of e.events)document.removeEventListener(o,r,!0);n()};for(let o of e.events)document.addEventListener(o,r,{capture:!0,passive:!0});return}case"media":{if(typeof matchMedia>"u"){n();return}let r=matchMedia(e.query);if(r.matches){n();return}let o=s=>{s.matches&&(r.removeEventListener("change",o),n())};r.addEventListener("change",o);return}default:n()}}
+"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);
+
+// src/lib/render/deferred.ts
+var deferred_exports = {};
+__export(deferred_exports, {
+  deferred: () => deferred
+});
+module.exports = __toCommonJS(deferred_exports);
+var import_dom2 = require("@fluixi/dom");
+var import_signal2 = require("@fluixi/reactive/signal");
+var import_utils = require("@fluixi/dom/utils");
+
+// src/lib/render/lazy.ts
+var import_dom = require("@fluixi/dom");
+var import_signal = require("@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((0, import_signal.untrack)(() => C(props)));
+    }
+    if (!component) {
+      const [resource] = (0, import_signal.createResource)(() => load(), { transport: false });
+      component = resource;
+      if (resource.error) throw resource.error;
+    }
+    return (0, import_signal.createMemo)(() => {
+      const C = component();
+      return C ? fromChunk((0, import_dom.createComponent)(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/render/deferred.ts
+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 (0, import_dom2.isServer)() ? Lazy(props) : null;
+    if ((0, import_dom2.isServer)() || options.strategy.kind === "eager") return Lazy(props);
+    const [ready, setReady] = (0, import_signal2.createSignal)(false);
+    const start = () => {
+      void Lazy.preload().then(() => setReady(true));
+    };
+    const anchor = options.strategy.kind === "visible" ? createAnchor() : void 0;
+    schedule(options.strategy, start, anchor);
+    return (0, import_signal2.createMemo)(() => 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 = (0, import_utils.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();
+  }
+}

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

@@ -1,10 +1,10 @@
 /**
- * `deferred(loader, options)` — a component whose module is fetched on a schedule.
+ * `deferred(loader, options)`, a component whose module is fetched on a schedule.
  *
  * This is the runtime half of the `load:` directive. It adds only the *when*: which
  * browser signal starts the download. Resolution, Suspense integration and the
  * synchronous-when-preloaded hydration path all come from {@link lazy}, reused unchanged
- * — so a deferred component behaves exactly like a lazy one once its trigger fires.
+ *, so a deferred component behaves exactly like a lazy one once its trigger fires.
  *
  * There is no registry and no runtime name lookup. The compiler emits a call with a
  * literal `import()`, which is what lets the bundler do chunking, hashing and
@@ -33,7 +33,7 @@ export function deferred(loader, options) {
     }), { fallback: options.fallback });
     function Deferred(props) {
         // `never` is server-only: the component renders during SSR and its code is meant to
-        // stay out of the client bundle entirely. The compiler is what actually drops it —
+        // stay out of the client bundle entirely. The compiler is what actually drops it
         // this guard only stops the client from fetching it if one slips through.
         if (options.strategy.kind === 'never')
             return isServer() ? Lazy(props) : null;
@@ -65,7 +65,7 @@ function createAnchor() {
     el.style.display = 'block';
     return el;
 }
-/** Run `start` when the strategy's trigger fires. Idempotent — it fires at most once. */
+/** Run `start` when the strategy's trigger fires. Idempotent, it fires at most once. */
 function schedule(strategy, start, anchor) {
     let fired = false;
     const once = () => {
@@ -88,7 +88,7 @@ function schedule(strategy, start, anchor) {
         }
         case 'visible': {
             // Without an observer there is no signal to wait for, so load rather than never
-            // rendering — a missing capability should degrade to eager, not to broken.
+            // rendering, a missing capability should degrade to eager, not to broken.
             if (!anchor || typeof IntersectionObserver === 'undefined') {
                 once();
                 return;

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

@@ -1 +1,158 @@
-import{isServer as l}from"@fluixi/dom";import{createMemo as k,createSignal as g}from"@fluixi/reactive/signal";import{observeIntersection as h}from"@fluixi/dom/utils";import{createComponent as m}from"@fluixi/dom";import{untrack as p,createMemo as y,createResource as v}from"@fluixi/reactive/signal";function u(n){if(n!=null&&(typeof n=="object"||typeof n=="function"))try{n.$lazy=!0}catch{}return n}function f(n,i){let d,o,r;function e(){return o||(o=n().then(s=>d=s.default)),o}i?.preload&&e();let t=(s=>{if(d){let a=d;return u(p(()=>a(s)))}if(!r){let[a]=v(()=>e(),{transport:!1});if(r=a,a.error)throw a.error}return y(()=>{let a=r();return a?u(m(a,s)):void 0})});return t.preload=()=>e().then(()=>{}),t.$lazy=!0,t.loader=n,t}function O(n,i){let d=i.export??"default",o=f(()=>n().then(e=>{let t=e[d];if(typeof t!="function")throw new Error(`deferred(): module has no '${d}' export (got ${typeof t}).`);return{default:t}}),{fallback:i.fallback});function r(e){if(i.strategy.kind==="never")return l()?o(e):null;if(l()||i.strategy.kind==="eager")return o(e);let[t,s]=g(!1),a=()=>{o.preload().then(()=>s(!0))},c=i.strategy.kind==="visible"?b():void 0;return C(i.strategy,a,c),k(()=>t()?o(e):c??i.fallback??null,void 0,{name:"deferred"})}return r.preload=o.preload,r}function b(){let n=document.createElement("span");return n.setAttribute("data-fx-load","visible"),n.style.display="block",n}function C(n,i,d){let o=!1,r=()=>{o||(o=!0,i())};switch(n.kind){case"idle":{let e=globalThis.requestIdleCallback;e?e(r):setTimeout(r,1);return}case"visible":{if(!d||typeof IntersectionObserver>"u"){r();return}let e=h(d,t=>{t&&(e(),r())},{rootMargin:n.rootMargin??"0px"});return}case"interaction":{let e=()=>{for(let t of n.events)document.removeEventListener(t,e,!0);r()};for(let t of n.events)document.addEventListener(t,e,{capture:!0,passive:!0});return}case"media":{if(typeof matchMedia>"u"){r();return}let e=matchMedia(n.query);if(e.matches){r();return}let t=s=>{s.matches&&(e.removeEventListener("change",t),r())};e.addEventListener("change",t);return}default:r()}}export{O as deferred};
+// src/lib/render/deferred.ts
+import { isServer } from "@fluixi/dom";
+import { createMemo as createMemo2, createSignal } from "@fluixi/reactive/signal";
+import { observeIntersection } from "@fluixi/dom/utils";
+
+// src/lib/render/lazy.ts
+import { createComponent } from "@fluixi/dom";
+import {
+  untrack,
+  createMemo,
+  createResource
+} 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(untrack(() => C(props)));
+    }
+    if (!component) {
+      const [resource] = createResource(() => load(), { transport: false });
+      component = resource;
+      if (resource.error) throw resource.error;
+    }
+    return createMemo(() => {
+      const C = component();
+      return C ? fromChunk(createComponent(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/render/deferred.ts
+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 isServer() ? Lazy(props) : null;
+    if (isServer() || options.strategy.kind === "eager") return Lazy(props);
+    const [ready, setReady] = createSignal(false);
+    const start = () => {
+      void Lazy.preload().then(() => setReady(true));
+    };
+    const anchor = options.strategy.kind === "visible" ? createAnchor() : void 0;
+    schedule(options.strategy, start, anchor);
+    return createMemo2(() => 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();
+  }
+}
+export {
+  deferred
+};