@askrjs/askr 0.0.1

package/dist/index.js

@@ -0,0 +1,683 @@
+import {
+  initializeNavigation,
+  navigate,
+  registerAppInstance
+} from "./chunk-UUM5W2RM.js";
+import {
+  SSRDataMissingError,
+  collectResources,
+  getCurrentRenderData,
+  getCurrentSSRContext,
+  getNextKey,
+  renderToStream,
+  renderToString,
+  renderToStringSync,
+  renderToStringSyncForUrl,
+  resolveResources,
+  throwSSRDataMissing
+} from "./chunk-HIWJVOS4.js";
+import {
+  cleanupComponent,
+  clearRoutes,
+  createComponentInstance,
+  defineContext,
+  getCurrentComponentInstance,
+  getCurrentContextFrame,
+  getCurrentInstance,
+  getLoadedNamespaces,
+  getNamespaceRoutes,
+  getNextStateIndex,
+  getRoutes,
+  getSignal,
+  globalScheduler,
+  init_component,
+  init_context,
+  init_dom,
+  init_fastlane,
+  init_invariant,
+  init_logger,
+  init_scheduler,
+  invariant,
+  isBulkCommitActive,
+  logger,
+  mountComponent,
+  readContext,
+  removeAllListeners,
+  route,
+  scheduleEventHandler,
+  setServerLocation,
+  unloadNamespace,
+  withAsyncResourceContext
+} from "./chunk-L7RL4LYV.js";
+import {
+  Fragment,
+  init_jsx_runtime,
+  jsx,
+  jsxs
+} from "./chunk-YNH3D4KW.js";
+import "./chunk-4CV4JOE5.js";
+
+// src/runtime/state.ts
+init_scheduler();
+init_component();
+init_invariant();
+init_fastlane();
+function state(initialValue) {
+  const instance = getCurrentInstance();
+  if (!instance) {
+    throw new Error(
+      "state() can only be called during component render execution. Move state() calls to the top level of your component function."
+    );
+  }
+  const index = getNextStateIndex();
+  const stateValues = instance.stateValues;
+  if (index < instance.stateIndexCheck) {
+    throw new Error(
+      `State index violation: state() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. This happens when state() is called conditionally (inside if/for/etc). Move all state() calls to the top level of your component function, before any conditionals.`
+    );
+  }
+  invariant(
+    index >= instance.stateIndexCheck,
+    "[State] State indices must increase monotonically"
+  );
+  instance.stateIndexCheck = index;
+  if (instance.firstRenderComplete) {
+    if (!instance.expectedStateIndices.includes(index)) {
+      throw new Error(
+        `Hook order violation: state() called at index ${index}, but this index was not in the first render's sequence [${instance.expectedStateIndices.join(", ")}]. This usually means state() is inside a conditional or loop. Move all state() calls to the top level of your component function.`
+      );
+    }
+  } else {
+    instance.expectedStateIndices.push(index);
+  }
+  if (stateValues[index]) {
+    const existing = stateValues[index];
+    if (existing._owner !== instance) {
+      throw new Error(
+        `State ownership violation: state() called at index ${index} is owned by a different component instance. State ownership is positional and immutable.`
+      );
+    }
+    return existing;
+  }
+  const cell = createStateCell(initialValue, instance);
+  stateValues[index] = cell;
+  return cell;
+}
+function createStateCell(initialValue, instance) {
+  let value = initialValue;
+  const readers = /* @__PURE__ */ new Map();
+  function read() {
+    read._hasBeenRead = true;
+    const inst = getCurrentInstance();
+    if (inst && inst._currentRenderToken !== void 0) {
+      if (!inst._pendingReadStates) inst._pendingReadStates = /* @__PURE__ */ new Set();
+      inst._pendingReadStates.add(read);
+    }
+    return value;
+  }
+  read._readers = readers;
+  read._owner = instance;
+  read.set = (newValue) => {
+    const currentInst = getCurrentInstance();
+    if (currentInst !== null && process.env.NODE_ENV !== "production") {
+      throw new Error(
+        `[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.`
+      );
+    }
+    if (currentInst !== null && process.env.NODE_ENV === "production") {
+      return;
+    }
+    if (Object.is(value, newValue)) return;
+    if (isBulkCommitActive()) {
+      value = newValue;
+      return;
+    }
+    value = newValue;
+    const readersMap = read._readers;
+    if (readersMap) {
+      for (const [subInst, token] of readersMap) {
+        if (subInst.lastRenderToken !== token) continue;
+        if (!subInst.hasPendingUpdate) {
+          subInst.hasPendingUpdate = true;
+          const subTask = subInst._pendingFlushTask;
+          if (subTask) globalScheduler.enqueue(subTask);
+          else
+            globalScheduler.enqueue(() => {
+              subInst.hasPendingUpdate = false;
+              subInst.notifyUpdate?.();
+            });
+        }
+      }
+    }
+    const readersMapForOwner = readersMap;
+    const ownerRecordedToken = readersMapForOwner?.get(instance);
+    const ownerShouldEnqueue = (
+      // Normal case: owner read this state in last committed render
+      ownerRecordedToken !== void 0 && instance.lastRenderToken === ownerRecordedToken
+    );
+    if (ownerShouldEnqueue && !instance.hasPendingUpdate) {
+      instance.hasPendingUpdate = true;
+      const task = instance._pendingFlushTask;
+      if (task) globalScheduler.enqueue(task);
+      else
+        globalScheduler.enqueue(() => {
+          instance.hasPendingUpdate = false;
+          instance.notifyUpdate?.();
+        });
+    }
+  };
+  return read;
+}
+
+// src/index.ts
+init_component();
+init_scheduler();
+init_context();
+
+// src/runtime/operations.ts
+init_component();
+init_context();
+
+// src/runtime/resource_cell.ts
+init_context();
+init_logger();
+var ResourceCell = class {
+  constructor(fn, deps, resourceFrame) {
+    this.value = null;
+    this.pending = true;
+    this.error = null;
+    this.generation = 0;
+    this.controller = null;
+    this.deps = null;
+    this.resourceFrame = null;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.fn = fn;
+    this.deps = deps ? deps.slice() : null;
+    this.resourceFrame = resourceFrame;
+    this.snapshot = {
+      value: null,
+      pending: true,
+      error: null,
+      refresh: () => this.refresh()
+    };
+  }
+  subscribe(cb) {
+    this.subscribers.add(cb);
+    return () => this.subscribers.delete(cb);
+  }
+  notifySubscribers() {
+    this.snapshot.value = this.value;
+    this.snapshot.pending = this.pending;
+    this.snapshot.error = this.error;
+    for (const cb of this.subscribers) cb();
+  }
+  start(ssr = false, notify = true) {
+    const generation = this.generation;
+    this.controller?.abort();
+    const controller = new AbortController();
+    this.controller = controller;
+    this.pending = true;
+    this.error = null;
+    if (notify) this.notifySubscribers();
+    let result;
+    try {
+      result = withAsyncResourceContext(
+        this.resourceFrame,
+        () => this.fn({ signal: controller.signal })
+      );
+    } catch (err) {
+      this.pending = false;
+      this.error = err;
+      if (notify) this.notifySubscribers();
+      return;
+    }
+    if (!(result instanceof Promise)) {
+      this.value = result;
+      this.pending = false;
+      this.error = null;
+      if (notify) this.notifySubscribers();
+      return;
+    }
+    if (ssr) {
+      throwSSRDataMissing();
+    }
+    result.then((val) => {
+      if (this.generation !== generation) return;
+      if (this.controller !== controller) return;
+      this.value = val;
+      this.pending = false;
+      this.error = null;
+      this.notifySubscribers();
+    }).catch((err) => {
+      if (this.generation !== generation) return;
+      this.pending = false;
+      this.error = err;
+      try {
+        logger.error("[Askr] Async resource error:", err);
+      } catch {
+      }
+      this.notifySubscribers();
+    });
+  }
+  refresh() {
+    this.generation++;
+    this.controller?.abort();
+    this.start();
+  }
+  abort() {
+    this.controller?.abort();
+  }
+};
+
+// src/runtime/operations.ts
+function resource(fn, deps = []) {
+  const instance = getCurrentComponentInstance();
+  const inst = instance;
+  if (!instance) {
+    const renderData2 = getCurrentRenderData();
+    if (renderData2) {
+      const key = getNextKey();
+      if (!(key in renderData2)) {
+        throwSSRDataMissing();
+      }
+      const val = renderData2[key];
+      return {
+        value: val,
+        pending: false,
+        error: null,
+        refresh: () => {
+        }
+      };
+    }
+    const ssrCtx = getCurrentSSRContext();
+    if (ssrCtx) {
+      throwSSRDataMissing();
+    }
+    return {
+      value: null,
+      pending: true,
+      error: null,
+      refresh: () => {
+      }
+    };
+  }
+  const renderData = getCurrentRenderData();
+  if (renderData) {
+    const key = getNextKey();
+    if (!(key in renderData)) {
+      throwSSRDataMissing();
+    }
+    const val = renderData[key];
+    const holder2 = state({
+      cell: void 0,
+      snapshot: {
+        value: val,
+        pending: false,
+        error: null,
+        refresh: () => {
+        }
+      }
+    });
+    const h2 = holder2();
+    h2.snapshot.value = val;
+    h2.snapshot.pending = false;
+    h2.snapshot.error = null;
+    holder2.set(h2);
+    return h2.snapshot;
+  }
+  const holder = state({
+    cell: void 0,
+    snapshot: {
+      value: null,
+      pending: true,
+      error: null,
+      refresh: () => {
+      }
+    }
+  });
+  const h = holder();
+  if (!h.cell) {
+    const frame = getCurrentContextFrame();
+    const cell2 = new ResourceCell(fn, deps, frame);
+    h.cell = cell2;
+    h.snapshot = cell2.snapshot;
+    const unsubscribe = cell2.subscribe(() => {
+      const cur = holder();
+      cur.snapshot.value = cell2.snapshot.value;
+      cur.snapshot.pending = cell2.snapshot.pending;
+      cur.snapshot.error = cell2.snapshot.error;
+      holder.set(cur);
+      try {
+        inst._enqueueRun?.();
+      } catch {
+      }
+    });
+    inst.cleanupFns.push(() => {
+      unsubscribe();
+      cell2.abort();
+    });
+    try {
+      cell2.start(inst.ssr ?? false, false);
+      if (!cell2.pending) {
+        const cur = holder();
+        cur.snapshot.value = cell2.value;
+        cur.snapshot.pending = cell2.pending;
+        cur.snapshot.error = cell2.error;
+      }
+    } catch (err) {
+      if (err instanceof SSRDataMissingError) throw err;
+      cell2.error = err;
+      cell2.pending = false;
+      const cur = holder();
+      cur.snapshot.value = cell2.value;
+      cur.snapshot.pending = cell2.pending;
+      cur.snapshot.error = cell2.error;
+    }
+  }
+  const cell = h.cell;
+  const depsChanged = !cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => d !== deps[i]);
+  if (depsChanged) {
+    cell.deps = deps.slice();
+    cell.generation++;
+    cell.pending = true;
+    cell.error = null;
+    try {
+      cell.start(inst.ssr ?? false, false);
+      if (!cell.pending) {
+        const cur = holder();
+        cur.snapshot.value = cell.value;
+        cur.snapshot.pending = cell.pending;
+        cur.snapshot.error = cell.error;
+      }
+    } catch (err) {
+      if (err instanceof SSRDataMissingError) throw err;
+      cell.error = err;
+      cell.pending = false;
+      const cur = holder();
+      cur.snapshot.value = cell.value;
+      cur.snapshot.pending = cell.pending;
+      cur.snapshot.error = cell.error;
+    }
+  }
+  return h.snapshot;
+}
+
+// src/app/createApp.ts
+init_component();
+init_scheduler();
+init_logger();
+init_dom();
+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);
+  };
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(rootElement, "innerHTML") || Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(rootElement),
+      "innerHTML"
+    ) || Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML");
+    if (descriptor && (descriptor.get || descriptor.set)) {
+      Object.defineProperty(rootElement, "innerHTML", {
+        get: descriptor.get ? function() {
+          return descriptor.get.call(this);
+        } : void 0,
+        set: function(value) {
+          if (value === "" && instancesByRoot.get(this) === instance) {
+            removeAllListeners(rootElement);
+            cleanupComponent(instance);
+          }
+          if (descriptor.set) {
+            return descriptor.set.call(this, value);
+          }
+        },
+        configurable: true
+      });
+    }
+  } catch {
+  }
+}
+function mountOrUpdate(rootElement, componentFn) {
+  const existingCleanup = rootElement[CLEANUP_SYMBOL];
+  if (existingCleanup) existingCleanup();
+  let instance = instancesByRoot.get(rootElement);
+  if (instance) {
+    removeAllListeners(rootElement);
+    cleanupComponent(instance);
+    instance.fn = componentFn;
+    instance.evaluationGeneration++;
+    instance.mounted = false;
+    instance.expectedStateIndices = [];
+    instance.firstRenderComplete = false;
+    instance.isRoot = true;
+  } else {
+    const componentId = String(++componentIdCounter);
+    instance = createComponentInstance(
+      componentId,
+      componentFn,
+      {},
+      rootElement
+    );
+    instancesByRoot.set(rootElement, instance);
+    instance.isRoot = true;
+  }
+  attachCleanupForRoot(rootElement, instance);
+  mountComponent(instance);
+  globalScheduler.flush();
+}
+function createIsland(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("createIsland requires a config object");
+  }
+  if (typeof config.component !== "function") {
+    throw new Error("createIsland: component must be a function");
+  }
+  const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
+  if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+  if ("routes" in config) {
+    throw new Error(
+      "createIsland does not accept routes; use createSPA for routed apps"
+    );
+  }
+  mountOrUpdate(rootElement, config.component);
+}
+async function createSPA(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("createSPA requires a config object");
+  }
+  if (!Array.isArray(config.routes) || config.routes.length === 0) {
+    throw new Error(
+      "createSPA requires a route table. If you are enhancing existing HTML, use createIsland instead."
+    );
+  }
+  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");
+  clearRoutes2();
+  for (const r of config.routes) {
+    route2(r.path, r.handler, r.namespace);
+  }
+  if (process.env.NODE_ENV === "production") lockRouteRegistration();
+  const path = typeof window !== "undefined" ? window.location.pathname : "/";
+  const resolved = resolveRoute(path);
+  if (!resolved) {
+    if (process.env.NODE_ENV !== "production") {
+      logger.warn(
+        `createSPA: no route found for current path (${path}). Mounting empty placeholder; navigation will activate routes when requested.`
+      );
+    }
+    mountOrUpdate(rootElement, () => ({ type: "div", children: [] }));
+    const instance2 = instancesByRoot.get(rootElement);
+    if (!instance2) throw new Error("Internal error: app instance missing");
+    registerAppInstance(instance2, path);
+    initializeNavigation();
+    return;
+  }
+  mountOrUpdate(rootElement, resolved.handler);
+  const instance = instancesByRoot.get(rootElement);
+  if (!instance) throw new Error("Internal error: app instance missing");
+  registerAppInstance(instance, path);
+  initializeNavigation();
+}
+async function hydrateSPA(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("hydrateSPA requires a config object");
+  }
+  if (!Array.isArray(config.routes) || config.routes.length === 0) {
+    throw new Error(
+      "hydrateSPA requires a route table. If you are enhancing existing HTML, use createIsland instead."
+    );
+  }
+  const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
+  if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+  const serverHTML = rootElement.innerHTML;
+  const {
+    clearRoutes: clearRoutes2,
+    route: route2,
+    setServerLocation: setServerLocation2,
+    lockRouteRegistration,
+    resolveRoute
+  } = await import("./route-TVYWYCEJ.js");
+  clearRoutes2();
+  for (const r of config.routes) {
+    route2(r.path, r.handler, r.namespace);
+  }
+  const path = typeof window !== "undefined" ? window.location.pathname : "/";
+  setServerLocation2(path);
+  if (process.env.NODE_ENV === "production") lockRouteRegistration();
+  const resolved = resolveRoute(path);
+  if (!resolved) {
+    throw new Error(`hydrateSPA: no route found for current path (${path}).`);
+  }
+  const { renderToStringSync: renderToStringSync2 } = await import("./ssr-4ELUFK65.js");
+  const expectedHTML = renderToStringSync2(() => {
+    const out = resolved.handler(resolved.params);
+    return out ?? {
+      type: "div",
+      children: []
+    };
+  });
+  const serverContainer = document.createElement("div");
+  serverContainer.innerHTML = serverHTML;
+  const expectedContainer = document.createElement("div");
+  expectedContainer.innerHTML = expectedHTML;
+  if (!serverContainer.isEqualNode(expectedContainer)) {
+    throw new Error(
+      "[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");
+  const instance = instancesByRoot.get(rootElement);
+  if (!instance) throw new Error("Internal error: app instance missing");
+  registerAppInstance2(instance, path);
+  initializeNavigation2();
+}
+function cleanupApp(root) {
+  const rootElement = typeof root === "string" ? document.getElementById(root) : root;
+  if (!rootElement) return;
+  const cleanupFn = rootElement[CLEANUP_SYMBOL];
+  if (typeof cleanupFn === "function") {
+    cleanupFn();
+  }
+  instancesByRoot.delete(rootElement);
+}
+function hasApp(root) {
+  const rootElement = typeof root === "string" ? document.getElementById(root) : root;
+  if (!rootElement) return false;
+  return instancesByRoot.has(rootElement);
+}
+
+// src/router/layouts.ts
+function layout(Layout) {
+  return (children) => Layout({ children });
+}
+
+// src/components/Link.tsx
+function Link({ href, children }) {
+  return {
+    type: "a",
+    props: {
+      href,
+      children,
+      onClick: (e) => {
+        const event = e;
+        const button = event.button ?? 0;
+        if (button !== 0 || // not left-click
+        event.ctrlKey || // Ctrl/Cmd+click
+        event.metaKey || // Cmd on Mac
+        event.shiftKey || // Shift+click
+        event.altKey) {
+          return;
+        }
+        event.preventDefault();
+        navigate(href);
+      }
+    }
+  };
+}
+
+// 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;
+  if (!g.route) g.route = route;
+  if (!g.getRoutes) g.getRoutes = getRoutes;
+  if (!g.navigate) g.navigate = navigate;
+}
+export {
+  Fragment,
+  Link,
+  cleanupApp,
+  clearRoutes,
+  collectResources,
+  createApp,
+  createIsland,
+  createSPA,
+  defineContext,
+  getLoadedNamespaces,
+  getNamespaceRoutes,
+  getRoutes,
+  getSignal,
+  hasApp,
+  hydrateSPA,
+  jsx,
+  jsxs,
+  layout,
+  navigate,
+  readContext,
+  renderToStream,
+  renderToString,
+  renderToStringSync,
+  renderToStringSyncForUrl,
+  resolveResources,
+  resource,
+  route,
+  scheduleEventHandler,
+  setServerLocation,
+  state,
+  unloadNamespace
+};
+//# sourceMappingURL=index.js.map