@askrjs/askr 0.0.1 → 0.0.2

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   initializeNavigation,
   navigate,
   registerAppInstance
-} from "./chunk-UUM5W2RM.js";
+} from "./chunk-RJWOOUYV.js";
 import {
   SSRDataMissingError,
   collectResources,
@@ -15,7 +15,7 @@ import {
   renderToStringSyncForUrl,
   resolveResources,
   throwSSRDataMissing
-} from "./chunk-HIWJVOS4.js";
+} from "./chunk-PFOLLB6A.js";
 import {
   cleanupComponent,
   clearRoutes,
@@ -32,36 +32,41 @@ import {
   globalScheduler,
   init_component,
   init_context,
-  init_dom,
-  init_fastlane,
+  init_fastlane_shared,
   init_invariant,
   init_logger,
+  init_renderer,
   init_scheduler,
   invariant,
   isBulkCommitActive,
   logger,
   mountComponent,
   readContext,
+  registerMountOperation,
   removeAllListeners,
   route,
   scheduleEventHandler,
   setServerLocation,
   unloadNamespace,
   withAsyncResourceContext
-} from "./chunk-L7RL4LYV.js";
+} from "./chunk-MIPES65F.js";
 import {
-  Fragment,
+  Fragment as Fragment2,
   init_jsx_runtime,
   jsx,
   jsxs
-} from "./chunk-YNH3D4KW.js";
-import "./chunk-4CV4JOE5.js";
+} from "./chunk-KR6HG7HF.js";
+import {
+  ELEMENT_TYPE,
+  Fragment,
+  init_types
+} from "./chunk-QECQ2TF6.js";
 
 // src/runtime/state.ts
 init_scheduler();
 init_component();
 init_invariant();
-init_fastlane();
+init_fastlane_shared();
 function state(initialValue) {
   const instance = getCurrentInstance();
   if (!instance) {
@@ -117,7 +122,7 @@ function createStateCell(initialValue, instance) {
   }
   read._readers = readers;
   read._owner = instance;
-  read.set = (newValue) => {
+  read.set = (newValueOrUpdater) => {
     const currentInst = getCurrentInstance();
     if (currentInst !== null && process.env.NODE_ENV !== "production") {
       throw new Error(
@@ -127,6 +132,13 @@ function createStateCell(initialValue, instance) {
     if (currentInst !== null && process.env.NODE_ENV === "production") {
       return;
     }
+    let newValue;
+    if (typeof newValueOrUpdater === "function") {
+      const updater = newValueOrUpdater;
+      newValue = updater(value);
+    } else {
+      newValue = newValueOrUpdater;
+    }
     if (Object.is(value, newValue)) return;
     if (isBulkCommitActive()) {
       value = newValue;
@@ -157,8 +169,8 @@ function createStateCell(initialValue, instance) {
     );
     if (ownerShouldEnqueue && !instance.hasPendingUpdate) {
       instance.hasPendingUpdate = true;
-      const task = instance._pendingFlushTask;
-      if (task) globalScheduler.enqueue(task);
+      const task2 = instance._pendingFlushTask;
+      if (task2) globalScheduler.enqueue(task2);
       else
         globalScheduler.enqueue(() => {
           instance.hasPendingUpdate = false;
@@ -253,7 +265,14 @@ var ResourceCell = class {
       this.pending = false;
       this.error = err;
       try {
-        logger.error("[Askr] Async resource error:", err);
+        if (this.ownerName) {
+          logger.error(
+            `[Askr] Async resource error in ${this.ownerName}:`,
+            err
+          );
+        } else {
+          logger.error("[Askr] Async resource error:", err);
+        }
       } catch {
       }
       this.notifySubscribers();
@@ -269,6 +288,17 @@ var ResourceCell = class {
   }
 };
 
+// src/shared/derive_cache.ts
+var deriveCacheMap = /* @__PURE__ */ new WeakMap();
+function getDeriveCache(instance) {
+  let cache = deriveCacheMap.get(instance);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    deriveCacheMap.set(instance, cache);
+  }
+  return cache;
+}
+
 // src/runtime/operations.ts
 function resource(fn, deps = []) {
   const instance = getCurrentComponentInstance();
@@ -339,6 +369,7 @@ function resource(fn, deps = []) {
   if (!h.cell) {
     const frame = getCurrentContextFrame();
     const cell2 = new ResourceCell(fn, deps, frame);
+    cell2.ownerName = inst.fn?.name || "<anonymous>";
     h.cell = cell2;
     h.snapshot = cell2.snapshot;
     const unsubscribe = cell2.subscribe(() => {
@@ -401,34 +432,100 @@ function resource(fn, deps = []) {
   }
   return h.snapshot;
 }
+function derive(source, map) {
+  if (map === void 0 && typeof source === "function") {
+    const value2 = source();
+    if (value2 == null) return null;
+    const instance2 = getCurrentComponentInstance();
+    if (!instance2) {
+      return value2;
+    }
+    const cache2 = getDeriveCache(instance2);
+    if (cache2.has(value2)) return cache2.get(value2);
+    cache2.set(value2, value2);
+    return value2;
+  }
+  let value;
+  if (typeof source === "function" && !("value" in source)) {
+    value = source();
+  } else {
+    value = source?.value ?? source;
+  }
+  if (value == null) return null;
+  const instance = getCurrentComponentInstance();
+  if (!instance) {
+    return map(value);
+  }
+  const cache = getDeriveCache(instance);
+  if (cache.has(value)) {
+    return cache.get(value);
+  }
+  const result = map(value);
+  cache.set(value, result);
+  return result;
+}
+function task(fn) {
+  const ownerIsRoot = getCurrentComponentInstance()?.isRoot ?? false;
+  registerMountOperation(async () => {
+    if (!ownerIsRoot) {
+      throw new Error("[Askr] task() may only be used in root components");
+    }
+    return await fn();
+  });
+}
 
-// src/app/createApp.ts
+// src/boot/index.ts
 init_component();
 init_scheduler();
 init_logger();
-init_dom();
+init_renderer();
 var componentIdCounter = 0;
 var instancesByRoot = /* @__PURE__ */ new WeakMap();
 var CLEANUP_SYMBOL = /* @__PURE__ */ Symbol.for("__tempoCleanup__");
-function createApp(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error("createApp requires a config object");
-  }
-  if ("routes" in config) {
-    throw new Error(
-      "The `createApp` API is removed. Use `createSPA({ root, routes })` for routed apps, or `hydrateSPA({ root, routes })` for SSR hydration."
-    );
-  }
-  const appCfg = config;
-  createIsland({
-    root: appCfg.root,
-    component: appCfg.component
-  });
-}
 function attachCleanupForRoot(rootElement, instance) {
   rootElement[CLEANUP_SYMBOL] = () => {
-    removeAllListeners(rootElement);
-    cleanupComponent(instance);
+    const errors = [];
+    try {
+      removeAllListeners(rootElement);
+    } catch (e) {
+      errors.push(e);
+    }
+    try {
+      const descendants = rootElement.querySelectorAll("*");
+      for (const d of Array.from(descendants)) {
+        try {
+          const inst = d.__ASKR_INSTANCE;
+          if (inst) {
+            try {
+              cleanupComponent(inst);
+            } catch (err) {
+              errors.push(err);
+            }
+            try {
+              delete d.__ASKR_INSTANCE;
+            } catch (err) {
+              errors.push(err);
+            }
+          }
+        } catch (err) {
+          errors.push(err);
+        }
+      }
+    } catch (e) {
+      errors.push(e);
+    }
+    try {
+      cleanupComponent(instance);
+    } catch (e) {
+      errors.push(e);
+    }
+    if (errors.length > 0) {
+      if (instance.cleanupStrict) {
+        throw new AggregateError(errors, `cleanup failed for app root`);
+      } else if (process.env.NODE_ENV !== "production") {
+        for (const err of errors) logger.warn("[Askr] cleanup error:", err);
+      }
+    }
   };
   try {
     const descriptor = Object.getOwnPropertyDescriptor(rootElement, "innerHTML") || Object.getOwnPropertyDescriptor(
@@ -442,8 +539,20 @@ function attachCleanupForRoot(rootElement, instance) {
         } : void 0,
         set: function(value) {
           if (value === "" && instancesByRoot.get(this) === instance) {
-            removeAllListeners(rootElement);
-            cleanupComponent(instance);
+            try {
+              removeAllListeners(rootElement);
+            } catch (e) {
+              if (instance.cleanupStrict) throw e;
+              if (process.env.NODE_ENV !== "production")
+                logger.warn("[Askr] cleanup error:", e);
+            }
+            try {
+              cleanupComponent(instance);
+            } catch (e) {
+              if (instance.cleanupStrict) throw e;
+              if (process.env.NODE_ENV !== "production")
+                logger.warn("[Askr] cleanup error:", e);
+            }
           }
           if (descriptor.set) {
             return descriptor.set.call(this, value);
@@ -455,19 +564,27 @@ function attachCleanupForRoot(rootElement, instance) {
   } catch {
   }
 }
-function mountOrUpdate(rootElement, componentFn) {
+function mountOrUpdate(rootElement, componentFn, options) {
   const existingCleanup = rootElement[CLEANUP_SYMBOL];
   if (existingCleanup) existingCleanup();
   let instance = instancesByRoot.get(rootElement);
   if (instance) {
     removeAllListeners(rootElement);
-    cleanupComponent(instance);
+    try {
+      cleanupComponent(instance);
+    } catch (e) {
+      if (process.env.NODE_ENV !== "production")
+        logger.warn("[Askr] prior cleanup threw:", e);
+    }
     instance.fn = componentFn;
     instance.evaluationGeneration++;
     instance.mounted = false;
     instance.expectedStateIndices = [];
     instance.firstRenderComplete = false;
     instance.isRoot = true;
+    if (options && typeof options.cleanupStrict === "boolean") {
+      instance.cleanupStrict = options.cleanupStrict;
+    }
   } else {
     const componentId = String(++componentIdCounter);
     instance = createComponentInstance(
@@ -478,6 +595,9 @@ function mountOrUpdate(rootElement, componentFn) {
     );
     instancesByRoot.set(rootElement, instance);
     instance.isRoot = true;
+    if (options && typeof options.cleanupStrict === "boolean") {
+      instance.cleanupStrict = options.cleanupStrict;
+    }
   }
   attachCleanupForRoot(rootElement, instance);
   mountComponent(instance);
@@ -497,7 +617,9 @@ function createIsland(config) {
       "createIsland does not accept routes; use createSPA for routed apps"
     );
   }
-  mountOrUpdate(rootElement, config.component);
+  mountOrUpdate(rootElement, config.component, {
+    cleanupStrict: config.cleanupStrict
+  });
 }
 async function createSPA(config) {
   if (!config || typeof config !== "object") {
@@ -510,7 +632,7 @@ async function createSPA(config) {
   }
   const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
   if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
-  const { clearRoutes: clearRoutes2, route: route2, lockRouteRegistration, resolveRoute } = await import("./route-TVYWYCEJ.js");
+  const { clearRoutes: clearRoutes2, route: route2, lockRouteRegistration, resolveRoute } = await import("./route-P5YQBT4T.js");
   clearRoutes2();
   for (const r of config.routes) {
     route2(r.path, r.handler, r.namespace);
@@ -524,14 +646,18 @@ async function createSPA(config) {
         `createSPA: no route found for current path (${path}). Mounting empty placeholder; navigation will activate routes when requested.`
       );
     }
-    mountOrUpdate(rootElement, () => ({ type: "div", children: [] }));
+    mountOrUpdate(rootElement, () => ({ type: "div", children: [] }), {
+      cleanupStrict: false
+    });
     const instance2 = instancesByRoot.get(rootElement);
     if (!instance2) throw new Error("Internal error: app instance missing");
     registerAppInstance(instance2, path);
     initializeNavigation();
     return;
   }
-  mountOrUpdate(rootElement, resolved.handler);
+  mountOrUpdate(rootElement, resolved.handler, {
+    cleanupStrict: false
+  });
   const instance = instancesByRoot.get(rootElement);
   if (!instance) throw new Error("Internal error: app instance missing");
   registerAppInstance(instance, path);
@@ -555,7 +681,7 @@ async function hydrateSPA(config) {
     setServerLocation: setServerLocation2,
     lockRouteRegistration,
     resolveRoute
-  } = await import("./route-TVYWYCEJ.js");
+  } = await import("./route-P5YQBT4T.js");
   clearRoutes2();
   for (const r of config.routes) {
     route2(r.path, r.handler, r.namespace);
@@ -567,7 +693,7 @@ async function hydrateSPA(config) {
   if (!resolved) {
     throw new Error(`hydrateSPA: no route found for current path (${path}).`);
   }
-  const { renderToStringSync: renderToStringSync2 } = await import("./ssr-4ELUFK65.js");
+  const { renderToStringSync: renderToStringSync2 } = await import("./ssr-65K3IJ6B.js");
   const expectedHTML = renderToStringSync2(() => {
     const out = resolved.handler(resolved.params);
     return out ?? {
@@ -584,8 +710,10 @@ async function hydrateSPA(config) {
       "[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output."
     );
   }
-  mountOrUpdate(rootElement, resolved.handler);
-  const { registerAppInstance: registerAppInstance2, initializeNavigation: initializeNavigation2 } = await import("./navigate-NLQOZQGM.js");
+  mountOrUpdate(rootElement, resolved.handler, {
+    cleanupStrict: false
+  });
+  const { registerAppInstance: registerAppInstance2, initializeNavigation: initializeNavigation2 } = await import("./navigate-SDZNA2ZE.js");
   const instance = instancesByRoot.get(rootElement);
   if (!instance) throw new Error("Internal error: app instance missing");
   registerAppInstance2(instance, path);
@@ -606,11 +734,6 @@ function hasApp(root) {
   return instancesByRoot.has(rootElement);
 }
 
-// src/router/layouts.ts
-function layout(Layout) {
-  return (children) => Layout({ children });
-}
-
 // src/components/Link.tsx
 function Link({ href, children }) {
   return {
@@ -635,11 +758,59 @@ function Link({ href, children }) {
   };
 }
 
+// src/foundations/layout.ts
+function layout(Layout) {
+  return (children, props) => Layout({ ...props, children });
+}
+
+// src/foundations/slot.ts
+init_logger();
+
+// src/jsx/index.ts
+init_types();
+
+// src/jsx/utils.ts
+init_types();
+function isElement(value) {
+  return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
+}
+function cloneElement(element, props) {
+  return {
+    ...element,
+    props: { ...element.props, ...props }
+  };
+}
+
+// src/foundations/slot.ts
+function Slot(props) {
+  if (props.asChild) {
+    const { children, ...rest } = props;
+    if (isElement(children)) {
+      return cloneElement(children, rest);
+    }
+    logger.warn("<Slot asChild> expects a single JSX element child.");
+    return null;
+  }
+  return { type: Fragment, props: { children: props.children } };
+}
+
+// src/foundations/portal.ts
+function definePortal() {
+  const slot = createPortalSlot();
+  function PortalHost() {
+    return slot.read();
+  }
+  PortalHost.render = function PortalRender(props) {
+    slot.write(props.children);
+    return null;
+  };
+  return PortalHost;
+}
+
 // src/index.ts
 init_jsx_runtime();
 if (typeof globalThis !== "undefined") {
   const g = globalThis;
-  if (!g.createApp) g.createApp = createApp;
   if (!g.createIsland) g.createIsland = createIsland;
   if (!g.createSPA) g.createSPA = createSPA;
   if (!g.hydrateSPA) g.hydrateSPA = hydrateSPA;
@@ -648,15 +819,17 @@ if (typeof globalThis !== "undefined") {
   if (!g.navigate) g.navigate = navigate;
 }
 export {
-  Fragment,
+  Fragment2 as Fragment,
   Link,
+  Slot,
   cleanupApp,
   clearRoutes,
   collectResources,
-  createApp,
   createIsland,
   createSPA,
   defineContext,
+  definePortal,
+  derive,
   getLoadedNamespaces,
   getNamespaceRoutes,
   getRoutes,
@@ -678,6 +851,7 @@ export {
   scheduleEventHandler,
   setServerLocation,
   state,
+  task,
   unloadNamespace
 };
 //# sourceMappingURL=index.js.map