@askrjs/askr 0.0.4 → 0.0.5

package/dist/fx.js

@@ -0,0 +1,636 @@
+// src/fx/timing.ts
+function debounce(fn, ms, options) {
+  let timeoutId = null;
+  const { leading = false, trailing = true } = options || {};
+  let lastArgs = null;
+  let lastThis = null;
+  let lastCallTime = 0;
+  const debounced = function(...args) {
+    const callTime = Date.now();
+    lastArgs = args;
+    lastThis = this;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    if (leading && callTime - lastCallTime >= ms) {
+      fn.apply(this, args);
+      lastCallTime = callTime;
+    }
+    if (trailing) {
+      timeoutId = setTimeout(() => {
+        fn.apply(lastThis, lastArgs);
+        timeoutId = null;
+        lastCallTime = Date.now();
+      }, ms);
+    }
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+function throttle(fn, ms, options) {
+  let lastCallTime = 0;
+  let timeoutId = null;
+  const { leading = true, trailing = true } = options || {};
+  let lastArgs = null;
+  let lastThis = null;
+  const throttled = function(...args) {
+    const callTime = Date.now();
+    lastArgs = args;
+    lastThis = this;
+    if (leading && callTime - lastCallTime >= ms) {
+      fn.apply(this, args);
+      lastCallTime = callTime;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    } else if (!leading && lastCallTime === 0) {
+      lastCallTime = callTime;
+    }
+    if (trailing && timeoutId === null) {
+      timeoutId = setTimeout(
+        () => {
+          fn.apply(lastThis, lastArgs);
+          lastCallTime = Date.now();
+          timeoutId = null;
+        },
+        ms - (callTime - lastCallTime)
+      );
+    }
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return throttled;
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return ((...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  });
+}
+function defer(fn) {
+  Promise.resolve().then(fn);
+}
+function raf(fn) {
+  let frameId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  return function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    if (frameId === null) {
+      frameId = requestAnimationFrame(() => {
+        fn.apply(lastThis, lastArgs);
+        frameId = null;
+      });
+    }
+  };
+}
+function idle(fn, options) {
+  if (typeof requestIdleCallback !== "undefined") {
+    requestIdleCallback(fn, options ? { timeout: options.timeout } : void 0);
+  } else {
+    Promise.resolve().then(() => {
+      setTimeout(fn, 0);
+    });
+  }
+}
+function timeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options) {
+  const {
+    maxAttempts = 3,
+    delayMs = 100,
+    backoff = (i) => delayMs * Math.pow(2, i)
+  } = options || {};
+  let lastError = null;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const delay = backoff(attempt);
+        await timeout(delay);
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+
+// src/dev/invariant.ts
+function invariant(condition, message, context) {
+  if (!condition) {
+    const contextStr = "";
+    throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+  }
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
+}
+
+// src/dev/logger.ts
+function callConsole(method, args) {
+  const c = typeof console !== "undefined" ? console : void 0;
+  if (!c) return;
+  const fn = c[method];
+  if (typeof fn === "function") {
+    try {
+      fn.apply(console, args);
+    } catch {
+    }
+  }
+}
+var logger = {
+  debug: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("debug", args);
+  },
+  info: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("info", args);
+  },
+  warn: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("warn", args);
+  },
+  error: (...args) => {
+    callConsole("error", args);
+  }
+};
+
+// src/runtime/scheduler.ts
+var MAX_FLUSH_DEPTH = 50;
+function isBulkCommitActive() {
+  try {
+    const fb = globalThis.__ASKR_FASTLANE;
+    return typeof fb?.isBulkCommitActive === "function" ? !!fb.isBulkCommitActive() : false;
+  } catch (e) {
+    return false;
+  }
+}
+var Scheduler = class {
+  constructor() {
+    this.q = [];
+    this.head = 0;
+    this.running = false;
+    this.inHandler = false;
+    this.depth = 0;
+    this.executionDepth = 0;
+    // for compat with existing diagnostics
+    // Monotonic flush version increments at end of each flush
+    this.flushVersion = 0;
+    // Best-effort microtask kick scheduling
+    this.kickScheduled = false;
+    // Escape hatch flag for runWithSyncProgress
+    this.allowSyncProgress = false;
+    // Waiters waiting for flushVersion >= target
+    this.waiters = [];
+    // Keep a lightweight taskCount for compatibility/diagnostics
+    this.taskCount = 0;
+  }
+  enqueue(task) {
+    assertSchedulingPrecondition(
+      typeof task === "function",
+      "enqueue() requires a function"
+    );
+    if (isBulkCommitActive() && !this.allowSyncProgress) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(
+          "[Scheduler] enqueue() during bulk commit (not allowed)"
+        );
+      }
+      return;
+    }
+    this.q.push(task);
+    this.taskCount++;
+    if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
+      this.kickScheduled = true;
+      queueMicrotask(() => {
+        this.kickScheduled = false;
+        if (this.running) return;
+        if (isBulkCommitActive()) return;
+        try {
+          this.flush();
+        } catch (err) {
+          setTimeout(() => {
+            throw err;
+          });
+        }
+      });
+    }
+  }
+  flush() {
+    invariant(
+      !this.running,
+      "[Scheduler] flush() called while already running"
+    );
+    if (process.env.NODE_ENV !== "production") {
+      if (isBulkCommitActive() && !this.allowSyncProgress) {
+        throw new Error(
+          "[Scheduler] flush() started during bulk commit (not allowed)"
+        );
+      }
+    }
+    this.running = true;
+    this.depth = 0;
+    let fatal = null;
+    try {
+      while (this.head < this.q.length) {
+        this.depth++;
+        if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
+          throw new Error(
+            `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
+          );
+        }
+        const task = this.q[this.head++];
+        try {
+          this.executionDepth++;
+          task();
+          this.executionDepth--;
+        } catch (err) {
+          if (this.executionDepth > 0) this.executionDepth = 0;
+          fatal = err;
+          break;
+        }
+        if (this.taskCount > 0) this.taskCount--;
+      }
+    } finally {
+      this.running = false;
+      this.depth = 0;
+      this.executionDepth = 0;
+      if (this.head >= this.q.length) {
+        this.q.length = 0;
+        this.head = 0;
+      } else if (this.head > 0) {
+        const remaining = this.q.length - this.head;
+        for (let i = 0; i < remaining; i++) {
+          this.q[i] = this.q[this.head + i];
+        }
+        this.q.length = remaining;
+        this.head = 0;
+      }
+      this.flushVersion++;
+      this.resolveWaiters();
+    }
+    if (fatal) throw fatal;
+  }
+  runWithSyncProgress(fn) {
+    const prev = this.allowSyncProgress;
+    this.allowSyncProgress = true;
+    const g = globalThis;
+    const origQueueMicrotask = g.queueMicrotask;
+    const origSetTimeout = g.setTimeout;
+    if (process.env.NODE_ENV !== "production") {
+      g.queueMicrotask = () => {
+        throw new Error(
+          "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
+        );
+      };
+      g.setTimeout = () => {
+        throw new Error(
+          "[Scheduler] setTimeout not allowed during runWithSyncProgress"
+        );
+      };
+    }
+    const startVersion = this.flushVersion;
+    try {
+      const res = fn();
+      if (!this.running && this.q.length - this.head > 0) {
+        this.flush();
+      }
+      if (process.env.NODE_ENV !== "production") {
+        if (this.q.length - this.head > 0) {
+          throw new Error(
+            "[Scheduler] tasks remain after runWithSyncProgress flush"
+          );
+        }
+      }
+      return res;
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        g.queueMicrotask = origQueueMicrotask;
+        g.setTimeout = origSetTimeout;
+      }
+      try {
+        if (this.flushVersion === startVersion) {
+          this.flushVersion++;
+          this.resolveWaiters();
+        }
+      } catch (e) {
+      }
+      this.allowSyncProgress = prev;
+    }
+  }
+  waitForFlush(targetVersion, timeoutMs = 2e3) {
+    const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
+    if (this.flushVersion >= target) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const ns = globalThis.__ASKR__ || {};
+        const diag = {
+          flushVersion: this.flushVersion,
+          queueLen: this.q.length - this.head,
+          running: this.running,
+          inHandler: this.inHandler,
+          bulk: isBulkCommitActive(),
+          namespace: ns
+        };
+        reject(
+          new Error(
+            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
+          )
+        );
+      }, timeoutMs);
+      this.waiters.push({ target, resolve, reject, timer });
+    });
+  }
+  getState() {
+    return {
+      queueLength: this.q.length - this.head,
+      running: this.running,
+      depth: this.depth,
+      executionDepth: this.executionDepth,
+      taskCount: this.taskCount,
+      flushVersion: this.flushVersion,
+      // New fields for optional inspection
+      inHandler: this.inHandler,
+      allowSyncProgress: this.allowSyncProgress
+    };
+  }
+  setInHandler(v) {
+    this.inHandler = v;
+  }
+  isInHandler() {
+    return this.inHandler;
+  }
+  isExecuting() {
+    return this.running || this.executionDepth > 0;
+  }
+  // Clear pending synchronous tasks (used by fastlane enter/exit)
+  clearPendingSyncTasks() {
+    const remaining = this.q.length - this.head;
+    if (remaining <= 0) return 0;
+    if (this.running) {
+      this.q.length = this.head;
+      this.taskCount = Math.max(0, this.taskCount - remaining);
+      queueMicrotask(() => {
+        try {
+          this.flushVersion++;
+          this.resolveWaiters();
+        } catch (e) {
+        }
+      });
+      return remaining;
+    }
+    this.q.length = 0;
+    this.head = 0;
+    this.taskCount = Math.max(0, this.taskCount - remaining);
+    this.flushVersion++;
+    this.resolveWaiters();
+    return remaining;
+  }
+  resolveWaiters() {
+    if (this.waiters.length === 0) return;
+    const ready = [];
+    const remaining = [];
+    for (const w of this.waiters) {
+      if (this.flushVersion >= w.target) {
+        if (w.timer) clearTimeout(w.timer);
+        ready.push(w.resolve);
+      } else {
+        remaining.push(w);
+      }
+    }
+    this.waiters = remaining;
+    for (const r of ready) r();
+  }
+};
+var globalScheduler = new Scheduler();
+
+// src/fx/noop.ts
+Object.assign((_ev) => {
+}, { cancel() {
+} });
+Object.assign((_ev) => {
+}, { cancel() {
+}, flush() {
+} });
+function enqueueUserCallback(fn) {
+  globalScheduler.enqueue(() => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error("[Askr] FX handler error:", err);
+    }
+  });
+}
+function debounceEvent(ms, handler, options) {
+  const { leading = false, trailing = true } = options || {};
+  let timeoutId = null;
+  let lastEvent = null;
+  let lastCallTime = 0;
+  const debounced = function(ev) {
+    const now = Date.now();
+    lastEvent = ev;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (leading && now - lastCallTime >= ms) {
+      enqueueUserCallback(() => handler.call(null, ev));
+      lastCallTime = now;
+    }
+    if (trailing) {
+      timeoutId = setTimeout(() => {
+        if (lastEvent) {
+          enqueueUserCallback(() => handler.call(null, lastEvent));
+        }
+        timeoutId = null;
+        lastCallTime = Date.now();
+      }, ms);
+    }
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastEvent = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      const ev = lastEvent;
+      lastEvent = null;
+      timeoutId = null;
+      if (ev) enqueueUserCallback(() => handler.call(null, ev));
+    }
+  };
+  return debounced;
+}
+function throttleEvent(ms, handler, options) {
+  const { leading = true, trailing = true } = options || {};
+  let lastCallTime = 0;
+  let timeoutId = null;
+  let lastEvent = null;
+  const throttled = function(ev) {
+    const now = Date.now();
+    lastEvent = ev;
+    if (leading && now - lastCallTime >= ms) {
+      enqueueUserCallback(() => handler.call(null, ev));
+      lastCallTime = now;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    } else if (!leading && lastCallTime === 0) {
+      lastCallTime = now;
+    }
+    if (trailing && timeoutId === null) {
+      const wait = ms - (now - lastCallTime);
+      timeoutId = setTimeout(
+        () => {
+          if (lastEvent)
+            enqueueUserCallback(() => handler.call(null, lastEvent));
+          lastCallTime = Date.now();
+          timeoutId = null;
+        },
+        Math.max(0, wait)
+      );
+    }
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastEvent = null;
+  };
+  return throttled;
+}
+function rafEvent(handler) {
+  let frameId = null;
+  let lastEvent = null;
+  const scheduleFrame = () => {
+    const rAF = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => setTimeout(() => cb(Date.now()), 16);
+    frameId = rAF(() => {
+      frameId = null;
+      if (lastEvent) {
+        const ev = lastEvent;
+        lastEvent = null;
+        enqueueUserCallback(() => handler.call(null, ev));
+      }
+    });
+  };
+  const fn = function(ev) {
+    lastEvent = ev;
+    if (frameId === null) scheduleFrame();
+  };
+  fn.cancel = () => {
+    if (frameId !== null) {
+      if (typeof cancelAnimationFrame !== "undefined" && typeof frameId === "number") {
+        cancelAnimationFrame(frameId);
+      } else {
+        clearTimeout(frameId);
+      }
+      frameId = null;
+    }
+    lastEvent = null;
+  };
+  return fn;
+}
+function scheduleTimeout(ms, fn) {
+  let id = setTimeout(() => {
+    id = null;
+    enqueueUserCallback(fn);
+  }, ms);
+  const cancel = () => {
+    if (id !== null) {
+      clearTimeout(id);
+      id = null;
+    }
+  };
+  return cancel;
+}
+function scheduleIdle(fn, options) {
+  let id = null;
+  let usingRIC = false;
+  if (typeof requestIdleCallback !== "undefined") {
+    usingRIC = true;
+    id = requestIdleCallback(() => {
+      id = null;
+      enqueueUserCallback(fn);
+    }, options);
+  } else {
+    id = setTimeout(() => {
+      id = null;
+      enqueueUserCallback(fn);
+    }, 0);
+  }
+  const cancel = () => {
+    if (id !== null) {
+      if (usingRIC && typeof cancelIdleCallback !== "undefined" && typeof id === "number") {
+        cancelIdleCallback(id);
+      } else {
+        clearTimeout(id);
+      }
+      id = null;
+    }
+  };
+  return cancel;
+}
+function scheduleRetry(fn, options) {
+  const {
+    maxAttempts = 3,
+    delayMs = 100,
+    backoff = (i) => delayMs * Math.pow(2, i)
+  } = options || {};
+  let cancelled = false;
+  const attempt = (index) => {
+    if (cancelled) return;
+    globalScheduler.enqueue(() => {
+      if (cancelled) return;
+      const p = fn();
+      p.then(
+        () => {
+        },
+        () => {
+          if (cancelled) return;
+          if (index + 1 < maxAttempts) {
+            const delay = backoff(index);
+            setTimeout(() => {
+              attempt(index + 1);
+            }, delay);
+          }
+        }
+      ).catch((e) => {
+        logger.error("[Askr] scheduleRetry error:", e);
+      });
+    });
+  };
+  attempt(0);
+  const cancel = () => {
+    cancelled = true;
+  };
+  return { cancel };
+}
+
+export { debounce, debounceEvent, defer, idle, once, raf, rafEvent, retry, scheduleIdle, scheduleRetry, scheduleTimeout, throttle, throttleEvent, timeout };
+//# sourceMappingURL=fx.js.map
+//# sourceMappingURL=fx.js.map