@fictjs/runtime 0.0.3 → 0.0.5

package/dist/slim.cjs

@@ -101,6 +101,7 @@ function reportCycle(reason, detail = void 0) {
 
 // src/lifecycle.ts
 var currentRoot;
+var currentEffectCleanups;
 var globalErrorHandlers = /* @__PURE__ */ new WeakMap();
 var globalSuspenseHandlers = /* @__PURE__ */ new WeakMap();
 function createRootContext(parent = currentRoot) {
@@ -130,6 +131,9 @@ function onDestroy(fn) {
   }
   runLifecycle(fn);
 }
+function onCleanup(fn) {
+  registerEffectCleanup(fn);
+}
 function flushOnMount(root) {
   const cbs = root.onMountCallbacks;
   if (!cbs || cbs.length === 0) return;
@@ -168,10 +172,35 @@ function destroyRoot(root) {
     globalSuspenseHandlers.delete(root);
   }
 }
+function createRoot(fn) {
+  const root = createRootContext();
+  const prev = pushRoot(root);
+  let value;
+  try {
+    value = fn();
+  } finally {
+    popRoot(prev);
+  }
+  flushOnMount(root);
+  return {
+    dispose: () => destroyRoot(root),
+    value
+  };
+}
 function withEffectCleanups(bucket, fn) {
+  const prev = currentEffectCleanups;
+  currentEffectCleanups = bucket;
   try {
     return fn();
   } finally {
+    currentEffectCleanups = prev;
+  }
+}
+function registerEffectCleanup(fn) {
+  if (currentEffectCleanups) {
+    currentEffectCleanups.push(fn);
+  } else {
+    registerRootCleanup(fn);
   }
 }
 function runCleanupList(list) {
@@ -720,6 +749,21 @@ function effect(fn) {
 function effectOper() {
   disposeNode(this);
 }
+function effectScope(fn) {
+  const e = { deps: void 0, depsTail: void 0, subs: void 0, subsTail: void 0, flags: 0 };
+  const prevSub = activeSub;
+  if (prevSub !== void 0) link(e, prevSub, 0);
+  activeSub = e;
+  try {
+    fn();
+  } finally {
+    activeSub = prevSub;
+  }
+  return effectScopeOper.bind(e);
+}
+function effectScopeOper() {
+  disposeNode(this);
+}
 function batch(fn) {
   ++batchDepth;
   try {
@@ -863,14 +907,6 @@ function createRenderEffect(fn) {
   return teardown;
 }
 
-// src/scheduler.ts
-function batch2(fn) {
-  return batch(fn);
-}
-function untrack2(fn) {
-  return untrack(fn);
-}
-
 // src/constants.ts
 var booleans = [
   "allowfullscreen",
@@ -1313,6 +1349,27 @@ function removeNodes(nodes) {
 function isReactive(value) {
   return typeof value === "function" && value.length === 0;
 }
+function callEventHandler(handler, event, node, data) {
+  if (!handler) return;
+  const context = node ?? event.currentTarget ?? void 0;
+  const invoke = (fn) => {
+    if (typeof fn === "function") {
+      const result = data === void 0 ? fn.call(context, event) : fn.call(context, data, event);
+      if (typeof result === "function" && result !== fn) {
+        if (data === void 0) {
+          result.call(context, event);
+        } else {
+          result.call(context, data, event);
+        }
+      } else if (result && typeof result.handleEvent === "function") {
+        result.handleEvent.call(result, event);
+      }
+    } else if (fn && typeof fn.handleEvent === "function") {
+      fn.handleEvent.call(fn, event);
+    }
+  };
+  invoke(handler);
+}
 var PRIMITIVE_PROXY = Symbol("fict:primitive-proxy");
 var PRIMITIVE_PROXY_RAW_VALUE = Symbol("fict:primitive-proxy:raw-value");
 function createValueProxy(read) {
@@ -1799,14 +1856,10 @@ function globalEventHandler(e) {
       const hasData = rawData !== void 0;
       const resolvedNodeData = hasData ? resolveData(rawData) : void 0;
       if (typeof handler === "function") {
-        if (hasData) {
-          handler.call(node, resolvedNodeData, e);
-        } else {
-          handler.call(node, e);
-        }
+        callEventHandler(handler, e, node, hasData ? resolvedNodeData : void 0);
       } else if (Array.isArray(handler)) {
         const tupleData = resolveData(handler[1]);
-        handler[0].call(node, tupleData, e);
+        callEventHandler(handler[0], e, node, tupleData);
       }
       if (e.cancelBubble) return false;
     }
@@ -1854,23 +1907,15 @@ function bindEvent(el, eventName, handler, options2) {
   if (DelegatedEvents.has(eventName) && !options2) {
     const key = `$$${eventName}`;
     delegateEvents([eventName]);
-    const createWrapped = (resolve) => {
-      const wrapped2 = function(...args) {
-        try {
-          const fn = resolve();
-          if (typeof fn === "function") {
-            return fn.apply(this, args);
-          } else if (fn && typeof fn.handleEvent === "function") {
-            return fn.handleEvent.apply(fn, args);
-          }
-        } catch (err) {
-          handleError(err, { source: "event", eventName }, rootRef);
-        }
-      };
-      return wrapped2;
-    };
     const resolveHandler = isReactive(handler) ? handler : () => handler;
-    el[key] = createWrapped(resolveHandler);
+    el[key] = function(...args) {
+      try {
+        const fn = resolveHandler();
+        callEventHandler(fn, args[0], el);
+      } catch (err) {
+        handleError(err, { source: "event", eventName }, rootRef);
+      }
+    };
     return () => {
       el[key] = void 0;
     };
@@ -1879,13 +1924,7 @@ function bindEvent(el, eventName, handler, options2) {
   const wrapped = (event) => {
     try {
       const resolved = getHandler();
-      if (typeof resolved === "function") {
-        ;
-        resolved(event);
-      } else if (resolved && typeof resolved.handleEvent === "function") {
-        ;
-        resolved.handleEvent(event);
-      }
+      callEventHandler(resolved, event, el);
     } catch (err) {
       if (handleError(err, { source: "event", eventName }, rootRef)) {
         return;
@@ -2344,6 +2383,46 @@ function bumpBlockVersion(block) {
   block.version(block.version() + 1);
 }
 
+// src/scope.ts
+function createScope() {
+  let dispose = null;
+  const stop = () => {
+    if (dispose) {
+      dispose();
+      dispose = null;
+    }
+  };
+  const run = (fn) => {
+    stop();
+    const { dispose: rootDispose, value } = createRoot(fn);
+    dispose = rootDispose;
+    return value;
+  };
+  registerRootCleanup(stop);
+  return { run, stop };
+}
+function runInScope(flag, fn) {
+  const scope = createScope();
+  const evaluate = () => isReactive(flag) ? flag() : !!flag;
+  createEffect(() => {
+    const enabled = evaluate();
+    if (enabled) {
+      scope.run(fn);
+    } else {
+      scope.stop();
+    }
+  });
+  onCleanup(scope.stop);
+}
+
+// src/scheduler.ts
+function batch2(fn) {
+  return batch(fn);
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
 // src/hooks.ts
 var ctxStack = [];
 function __fictUseContext() {
@@ -3363,10 +3442,12 @@ exports.createList = createList;
 exports.createMemo = createMemo;
 exports.createPropsProxy = createPropsProxy;
 exports.createRenderEffect = createRenderEffect;
+exports.createScope = createScope;
 exports.createSelector = createSelector;
 exports.createSignal = signal;
 exports.delegateEvents = delegateEvents;
 exports.destroyMarkerBlock = destroyMarkerBlock;
+exports.effectScope = effectScope;
 exports.getFirstNodeAfter = getFirstNodeAfter;
 exports.insert = insert;
 exports.insertNodesBefore = insertNodesBefore;
@@ -3376,6 +3457,7 @@ exports.onDestroy = onDestroy;
 exports.prop = __fictProp;
 exports.removeNodes = removeNodes;
 exports.render = render;
+exports.runInScope = runInScope;
 exports.template = template;
 exports.toNodeArray = toNodeArray;
 exports.untrack = untrack2;