@finesoft/front 0.1.3 → 0.1.11

package/dist/chunk-OVGQ4NUA.js

@@ -0,0 +1,1143 @@
+// ../core/src/actions/types.ts
+var ACTION_KINDS = {
+  FLOW: "flow",
+  EXTERNAL_URL: "externalUrl",
+  COMPOUND: "compound"
+};
+function isFlowAction(action) {
+  return action.kind === ACTION_KINDS.FLOW;
+}
+function isExternalUrlAction(action) {
+  return action.kind === ACTION_KINDS.EXTERNAL_URL;
+}
+function isCompoundAction(action) {
+  return action.kind === ACTION_KINDS.COMPOUND;
+}
+function makeFlowAction(url, presentationContext) {
+  return { kind: ACTION_KINDS.FLOW, url, presentationContext };
+}
+function makeExternalUrlAction(url) {
+  return { kind: ACTION_KINDS.EXTERNAL_URL, url };
+}
+
+// ../core/src/actions/dispatcher.ts
+var ActionDispatcher = class {
+  handlers = /* @__PURE__ */ new Map();
+  wiredActions = /* @__PURE__ */ new Set();
+  /** 注册指定 kind 的 handler（防止重复注册） */
+  onAction(kind, handler) {
+    if (this.wiredActions.has(kind)) {
+      console.warn(
+        `[ActionDispatcher] kind="${kind}" already registered, skipping`
+      );
+      return;
+    }
+    this.wiredActions.add(kind);
+    this.handlers.set(kind, handler);
+  }
+  /** 执行一个 Action（CompoundAction 递归展开） */
+  async perform(action) {
+    if (isCompoundAction(action)) {
+      for (const subAction of action.actions) {
+        await this.perform(subAction);
+      }
+      return;
+    }
+    const handler = this.handlers.get(action.kind);
+    if (!handler) {
+      console.warn(
+        `[ActionDispatcher] No handler for kind="${action.kind}"`
+      );
+      return;
+    }
+    await handler(action);
+  }
+};
+
+// ../core/src/intents/dispatcher.ts
+var IntentDispatcher = class {
+  controllers = /* @__PURE__ */ new Map();
+  /** 注册一个 IntentController */
+  register(controller) {
+    this.controllers.set(controller.intentId, controller);
+  }
+  /** 分发 Intent 到对应 Controller */
+  async dispatch(intent, container) {
+    const controller = this.controllers.get(intent.id);
+    if (!controller) {
+      throw new Error(
+        `[IntentDispatcher] No controller for "${intent.id}". Registered: [${Array.from(this.controllers.keys()).join(", ")}]`
+      );
+    }
+    return controller.perform(intent, container);
+  }
+  /** 检查是否已注册某个 Intent */
+  has(intentId) {
+    return this.controllers.has(intentId);
+  }
+};
+
+// ../core/src/dependencies/container.ts
+var Container = class {
+  registrations = /* @__PURE__ */ new Map();
+  /** 注册依赖（默认单例） */
+  register(key, factory, singleton = true) {
+    this.registrations.set(key, { factory, singleton });
+    return this;
+  }
+  /** 解析依赖 */
+  resolve(key) {
+    const reg = this.registrations.get(key);
+    if (!reg) {
+      throw new Error(`[Container] No registration for key: "${key}"`);
+    }
+    if (reg.singleton) {
+      if (reg.instance === void 0) {
+        reg.instance = reg.factory();
+      }
+      return reg.instance;
+    }
+    return reg.factory();
+  }
+  /** 检查是否已注册 */
+  has(key) {
+    return this.registrations.has(key);
+  }
+  /** 销毁容器，清除所有缓存 */
+  dispose() {
+    for (const reg of this.registrations.values()) {
+      reg.instance = void 0;
+    }
+    this.registrations.clear();
+  }
+};
+
+// ../core/src/logger/base.ts
+var BaseLogger = class {
+  category;
+  constructor(category) {
+    this.category = category;
+  }
+};
+
+// ../core/src/logger/local-storage-filter.ts
+var LEVEL_TO_NUM = {
+  "*": 4,
+  debug: 4,
+  info: 3,
+  warn: 2,
+  error: 1,
+  off: 0,
+  "": 0
+};
+var cachedRules;
+var cachedRaw;
+function parseRules() {
+  if (typeof globalThis.localStorage === "undefined") {
+    return {};
+  }
+  let raw;
+  try {
+    raw = globalThis.localStorage.getItem("onyxLog");
+  } catch {
+    return {};
+  }
+  if (!raw) return {};
+  if (raw === cachedRaw && cachedRules) return cachedRules;
+  cachedRaw = raw;
+  const rules = {};
+  const parts = raw.split(",");
+  for (const part of parts) {
+    const [name, level] = part.trim().split("=");
+    if (!name || level === void 0) continue;
+    const num = LEVEL_TO_NUM[level.toLowerCase()] ?? void 0;
+    if (num === void 0) continue;
+    if (name === "*") {
+      rules.defaultLevel = num;
+    } else {
+      rules.named ??= {};
+      rules.named[name] = num;
+    }
+  }
+  cachedRules = rules;
+  return rules;
+}
+function shouldLog(name, level) {
+  const rules = parseRules();
+  if (rules.defaultLevel === void 0 && !rules.named) {
+    return true;
+  }
+  const currentNum = LEVEL_TO_NUM[level] ?? 4;
+  if (rules.named?.[name] !== void 0) {
+    return currentNum <= rules.named[name];
+  }
+  if (rules.defaultLevel !== void 0) {
+    return currentNum <= rules.defaultLevel;
+  }
+  return true;
+}
+function resetFilterCache() {
+  cachedRules = void 0;
+  cachedRaw = void 0;
+}
+
+// ../core/src/logger/console.ts
+var ConsoleLogger = class extends BaseLogger {
+  debug(...args) {
+    if (shouldLog(this.category, "debug")) {
+      console.debug(`[${this.category}]`, ...args);
+    }
+    return "";
+  }
+  info(...args) {
+    if (shouldLog(this.category, "info")) {
+      console.info(`[${this.category}]`, ...args);
+    }
+    return "";
+  }
+  warn(...args) {
+    if (shouldLog(this.category, "warn")) {
+      console.warn(`[${this.category}]`, ...args);
+    }
+    return "";
+  }
+  error(...args) {
+    console.error(`[${this.category}]`, ...args);
+    return "";
+  }
+};
+var ConsoleLoggerFactory = class {
+  loggerFor(category) {
+    return new ConsoleLogger(category);
+  }
+};
+
+// ../core/src/dependencies/make-dependencies.ts
+var DEP_KEYS = {
+  LOGGER: "logger",
+  LOGGER_FACTORY: "loggerFactory",
+  NET: "net",
+  LOCALE: "locale",
+  STORAGE: "storage",
+  FEATURE_FLAGS: "featureFlags",
+  METRICS: "metrics",
+  FETCH: "fetch"
+};
+var DefaultLocale = class {
+  language = "en";
+  storefront = "us";
+  setActiveLocale(language, storefront) {
+    this.language = language;
+    this.storefront = storefront;
+  }
+};
+var MemoryStorage = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+};
+var DefaultFeatureFlags = class {
+  flags;
+  constructor(flags = {}) {
+    this.flags = flags;
+  }
+  isEnabled(key) {
+    return this.flags[key] === true;
+  }
+  getString(key) {
+    const v = this.flags[key];
+    return typeof v === "string" ? v : void 0;
+  }
+  getNumber(key) {
+    const v = this.flags[key];
+    return typeof v === "number" ? v : void 0;
+  }
+};
+var ConsoleMetrics = class {
+  recordPageView(page, fields) {
+    console.info(`[Metrics:PageView] ${page}`, fields ?? "");
+  }
+  recordEvent(name, fields) {
+    console.info(`[Metrics:Event] ${name}`, fields ?? "");
+  }
+};
+function makeDependencies(container, options = {}) {
+  const {
+    fetch: fetchFn = globalThis.fetch?.bind(globalThis),
+    language = "en",
+    storefront = "us",
+    featureFlags = {}
+  } = options;
+  const loggerFactory = new ConsoleLoggerFactory();
+  container.register(
+    DEP_KEYS.LOGGER_FACTORY,
+    () => loggerFactory
+  );
+  container.register(
+    DEP_KEYS.LOGGER,
+    () => loggerFactory.loggerFor("framework")
+  );
+  container.register(DEP_KEYS.NET, () => ({
+    fetch: (url, opts) => fetchFn(url, opts)
+  }));
+  container.register(DEP_KEYS.LOCALE, () => {
+    const locale = new DefaultLocale();
+    locale.setActiveLocale(language, storefront);
+    return locale;
+  });
+  container.register(DEP_KEYS.STORAGE, () => new MemoryStorage());
+  container.register(
+    DEP_KEYS.FEATURE_FLAGS,
+    () => new DefaultFeatureFlags(featureFlags)
+  );
+  container.register(
+    DEP_KEYS.METRICS,
+    () => new ConsoleMetrics()
+  );
+  container.register(DEP_KEYS.FETCH, () => fetchFn);
+}
+
+// ../core/src/router/router.ts
+var Router = class {
+  routes = [];
+  /** 添加路由规则 */
+  add(pattern, intentId) {
+    const paramNames = [];
+    const regexStr = pattern.replace(
+      /\/:(\w+)(\?)?/g,
+      (_, name, optional) => {
+        paramNames.push(name);
+        return optional ? "(?:/([^/]+))?" : "/([^/]+)";
+      }
+    );
+    this.routes.push({
+      pattern,
+      intentId,
+      regex: new RegExp(`^${regexStr}/?$`),
+      paramNames
+    });
+    return this;
+  }
+  /** 解析 URL → RouteMatch */
+  resolve(urlOrPath) {
+    const path = this.extractPath(urlOrPath);
+    const queryParams = this.extractQueryParams(urlOrPath);
+    for (const route of this.routes) {
+      const match = path.match(route.regex);
+      if (match) {
+        const params = {};
+        route.paramNames.forEach((name, index) => {
+          const value = match[index + 1];
+          if (value) params[name] = value;
+        });
+        for (const [k, v] of Object.entries(queryParams)) {
+          if (!(k in params)) params[k] = v;
+        }
+        return {
+          intent: { id: route.intentId, params },
+          action: makeFlowAction(urlOrPath)
+        };
+      }
+    }
+    return null;
+  }
+  /** 获取所有已注册的路由 */
+  getRoutes() {
+    return this.routes.map((r) => `${r.pattern} \u2192 ${r.intentId}`);
+  }
+  extractPath(url) {
+    try {
+      const parsed = new URL(url, "http://localhost");
+      return parsed.pathname;
+    } catch {
+      return url.split("?")[0].split("#")[0];
+    }
+  }
+  extractQueryParams(url) {
+    try {
+      const parsed = new URL(url, "http://localhost");
+      const params = {};
+      parsed.searchParams.forEach((v, k) => {
+        params[k] = v;
+      });
+      return params;
+    } catch {
+      return {};
+    }
+  }
+};
+
+// ../core/src/logger/composite.ts
+var CompositeLoggerFactory = class {
+  constructor(factories) {
+    this.factories = factories;
+  }
+  loggerFor(name) {
+    return new CompositeLogger(
+      this.factories.map((f) => f.loggerFor(name))
+    );
+  }
+};
+var CompositeLogger = class {
+  constructor(loggers) {
+    this.loggers = loggers;
+  }
+  debug(...args) {
+    return this.callAll("debug", args);
+  }
+  info(...args) {
+    return this.callAll("info", args);
+  }
+  warn(...args) {
+    return this.callAll("warn", args);
+  }
+  error(...args) {
+    return this.callAll("error", args);
+  }
+  callAll(method, args) {
+    for (const logger of this.loggers) {
+      logger[method](...args);
+    }
+    return "";
+  }
+};
+
+// ../core/src/prefetched-intents/stable-stringify.ts
+function stableStringify(obj) {
+  if (obj === null || obj === void 0) return String(obj);
+  if (typeof obj !== "object") return JSON.stringify(obj);
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(stableStringify).join(",") + "]";
+  }
+  const keys = Object.keys(obj).sort();
+  const parts = keys.filter((k) => obj[k] !== void 0).map(
+    (k) => JSON.stringify(k) + ":" + stableStringify(obj[k])
+  );
+  return "{" + parts.join(",") + "}";
+}
+
+// ../core/src/prefetched-intents/prefetched-intents.ts
+var PrefetchedIntents = class _PrefetchedIntents {
+  intents;
+  constructor(intents) {
+    this.intents = intents;
+  }
+  /** 从 PrefetchedIntent 数组创建缓存实例 */
+  static fromArray(items) {
+    const map = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (item.intent && item.data !== void 0) {
+        const key = stableStringify(item.intent);
+        map.set(key, item.data);
+      }
+    }
+    return new _PrefetchedIntents(map);
+  }
+  /** 创建空缓存实例 */
+  static empty() {
+    return new _PrefetchedIntents(/* @__PURE__ */ new Map());
+  }
+  /**
+   * 获取缓存的 Intent 结果（一次性使用）。
+   * 命中后从缓存中删除。
+   */
+  get(intent) {
+    const key = stableStringify(intent);
+    const data = this.intents.get(key);
+    if (data !== void 0) {
+      this.intents.delete(key);
+      return data;
+    }
+    return void 0;
+  }
+  /** 检查缓存中是否有某个 Intent 的数据 */
+  has(intent) {
+    return this.intents.has(stableStringify(intent));
+  }
+  /** 缓存中的条目数 */
+  get size() {
+    return this.intents.size;
+  }
+};
+
+// ../core/src/framework.ts
+var Framework = class _Framework {
+  container;
+  intentDispatcher;
+  actionDispatcher;
+  router;
+  prefetchedIntents;
+  constructor(container, prefetchedIntents) {
+    this.container = container;
+    this.intentDispatcher = new IntentDispatcher();
+    this.actionDispatcher = new ActionDispatcher();
+    this.router = new Router();
+    this.prefetchedIntents = prefetchedIntents;
+  }
+  /** 创建并初始化 Framework 实例 */
+  static create(config = {}) {
+    const container = new Container();
+    makeDependencies(container, config);
+    const fw = new _Framework(
+      container,
+      config.prefetchedIntents ?? PrefetchedIntents.empty()
+    );
+    config.setupRoutes?.(fw.router);
+    return fw;
+  }
+  /** 分发 Intent — 获取页面数据 */
+  async dispatch(intent) {
+    const logger = this.container.resolve(DEP_KEYS.LOGGER);
+    const cached = this.prefetchedIntents.get(intent);
+    if (cached !== void 0) {
+      logger.debug(
+        `[Framework] re-using prefetched intent response for: ${intent.id}`,
+        intent.params
+      );
+      return cached;
+    }
+    logger.debug(
+      `[Framework] dispatch intent: ${intent.id}`,
+      intent.params
+    );
+    return this.intentDispatcher.dispatch(intent, this.container);
+  }
+  /** 执行 Action — 处理用户交互 */
+  async perform(action) {
+    const logger = this.container.resolve(DEP_KEYS.LOGGER);
+    logger.debug(`[Framework] perform action: ${action.kind}`);
+    return this.actionDispatcher.perform(action);
+  }
+  /** 路由 URL — 将 URL 解析为 Intent + Action */
+  routeUrl(url) {
+    return this.router.resolve(url);
+  }
+  /** 记录页面访问事件 */
+  didEnterPage(page) {
+    const metrics = this.container.resolve(
+      DEP_KEYS.METRICS
+    );
+    metrics.recordPageView(page.pageType, {
+      pageId: page.id,
+      title: page.title
+    });
+  }
+  /** 注册 Action 处理器 */
+  onAction(kind, handler) {
+    this.actionDispatcher.onAction(kind, handler);
+  }
+  /** 注册 Intent Controller */
+  registerIntent(controller) {
+    this.intentDispatcher.register(controller);
+  }
+  /** 销毁 Framework 实例 */
+  dispose() {
+    this.container.dispose();
+  }
+};
+
+// ../core/src/http/client.ts
+var HttpError = class extends Error {
+  constructor(status, statusText, body) {
+    super(`HTTP ${status}: ${statusText}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "HttpError";
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  defaultHeaders;
+  fetchFn;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /** GET 请求，返回解析后的 JSON */
+  async get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  /** POST 请求，自动序列化 body 为 JSON */
+  async post(path, body, params) {
+    return this.request("POST", path, { body, params });
+  }
+  /** PUT 请求 */
+  async put(path, body, params) {
+    return this.request("PUT", path, { body, params });
+  }
+  /** DELETE 请求 */
+  async del(path, params) {
+    return this.request("DELETE", path, { params });
+  }
+  /**
+   * 底层请求方法 — 子类可覆写以自定义行为
+   *
+   * 自动处理:
+   * - URL 拼接 (baseUrl + path + params)
+   * - 默认 headers 合并
+   * - JSON body 序列化
+   * - 响应 JSON 解析
+   * - 非 2xx 状态码抛出 HttpError
+   */
+  async request(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = {
+      ...this.defaultHeaders,
+      ...options?.headers
+    };
+    const init = { method, headers };
+    if (options?.body !== void 0) {
+      headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+      init.body = JSON.stringify(options.body);
+    }
+    const response = await this.fetchFn(url, init);
+    if (!response.ok) {
+      const body = await response.text().catch(() => void 0);
+      throw new HttpError(response.status, response.statusText, body);
+    }
+    return response.json();
+  }
+  /** 构建完整 URL — 子类可覆写以自定义 URL 拼接逻辑 */
+  buildUrl(path, params) {
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${base}${normalizedPath}`, "http://placeholder");
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        url.searchParams.set(k, v);
+      }
+    }
+    if (this.baseUrl.startsWith("http")) {
+      return url.toString();
+    }
+    return `${url.pathname}${url.search}`;
+  }
+};
+
+// ../core/src/intents/base-controller.ts
+var BaseController = class {
+  /**
+   * 错误回退 — 子类可选覆写
+   *
+   * 当 execute() 抛出异常时调用。
+   * 默认行为: 重新抛出原始错误。
+   *
+   * @param params - Intent 参数
+   * @param error - execute() 抛出的错误
+   * @returns 回退数据
+   */
+  fallback(params, error) {
+    throw error;
+  }
+  /**
+   * IntentController.perform() 实现
+   *
+   * 自动 try/catch → fallback 模式。
+   */
+  async perform(intent, container) {
+    const params = intent.params ?? {};
+    try {
+      return await this.execute(params, container);
+    } catch (e) {
+      return this.fallback(
+        params,
+        e instanceof Error ? e : new Error(String(e))
+      );
+    }
+  }
+};
+
+// ../core/src/data/mapper.ts
+function pipe(...mappers) {
+  return (input) => mappers.reduce((acc, mapper) => mapper(acc), input);
+}
+function pipeAsync(...mappers) {
+  return async (input) => {
+    let acc = input;
+    for (const mapper of mappers) {
+      acc = await mapper(acc);
+    }
+    return acc;
+  };
+}
+function mapEach(mapper) {
+  return (items) => items.map(mapper);
+}
+
+// ../core/src/bootstrap/define-routes.ts
+function defineRoutes(framework, definitions) {
+  const registeredIntents = /* @__PURE__ */ new Set();
+  for (const def of definitions) {
+    if (def.controller && !registeredIntents.has(def.intentId)) {
+      framework.registerIntent(def.controller);
+      registeredIntents.add(def.intentId);
+    }
+    framework.router.add(def.path, def.intentId);
+  }
+}
+
+// ../core/src/utils/lru-map.ts
+var LruMap = class {
+  map = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.capacity) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) {
+        this.map.delete(oldest);
+      }
+    }
+    this.map.set(key, value);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  get size() {
+    return this.map.size;
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+
+// ../core/src/utils/optional.ts
+function isSome(value) {
+  return value !== null && value !== void 0;
+}
+function isNone(value) {
+  return value === null || value === void 0;
+}
+
+// ../core/src/utils/url.ts
+function removeScheme(url) {
+  return url.replace(/^https?:\/\//, "");
+}
+function removeHost(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname + parsed.search + parsed.hash;
+  } catch {
+    return url;
+  }
+}
+function removeQueryParams(url) {
+  return url.split("?")[0];
+}
+function getBaseUrl(url) {
+  return url.split("?")[0].split("#")[0];
+}
+function buildUrl(path, params) {
+  if (!params) return path;
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      searchParams.set(key, value);
+    }
+  }
+  const qs = searchParams.toString();
+  return qs ? `${path}?${qs}` : path;
+}
+
+// ../core/src/utils/uuid.ts
+function generateUuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// ../browser/src/action-handlers/external-url-action.ts
+function registerExternalUrlHandler(deps) {
+  const { framework, log } = deps;
+  framework.onAction(
+    ACTION_KINDS.EXTERNAL_URL,
+    (action) => {
+      log.debug(`ExternalUrlAction \u2192 ${action.url}`);
+      window.open(action.url, "_blank", "noopener,noreferrer");
+    }
+  );
+}
+
+// ../browser/src/utils/try-scroll.ts
+var MAX_TRIES = 100;
+var FUDGE = 16;
+var pendingFrame = null;
+function tryScroll(log, getScrollableElement, scrollY) {
+  if (pendingFrame !== null) {
+    cancelAnimationFrame(pendingFrame);
+    pendingFrame = null;
+  }
+  let tries = 0;
+  pendingFrame = requestAnimationFrame(function attempt() {
+    if (++tries >= MAX_TRIES) {
+      log.warn(
+        `tryScroll: gave up after ${MAX_TRIES} frames, target=${scrollY}`
+      );
+      pendingFrame = null;
+      return;
+    }
+    const el = getScrollableElement();
+    if (!el) {
+      log.warn(
+        "could not restore scroll: the scrollable element is missing"
+      );
+      return;
+    }
+    const { scrollHeight, offsetHeight } = el;
+    const canScroll = scrollY + offsetHeight <= scrollHeight + FUDGE;
+    if (!canScroll) {
+      log.info("page is not tall enough for scroll yet", {
+        scrollHeight,
+        offsetHeight
+      });
+      pendingFrame = requestAnimationFrame(attempt);
+      return;
+    }
+    el.scrollTop = scrollY;
+    log.info("scroll restored to", scrollY);
+    pendingFrame = null;
+  });
+}
+
+// ../browser/src/utils/history.ts
+var HISTORY_SIZE_LIMIT = 10;
+var History = class {
+  entries;
+  log;
+  getScrollablePageElement;
+  currentStateId;
+  constructor(log, options, sizeLimit = HISTORY_SIZE_LIMIT) {
+    this.entries = new LruMap(sizeLimit);
+    this.log = log;
+    this.getScrollablePageElement = options.getScrollablePageElement;
+  }
+  replaceState(state, url) {
+    const id = generateUuid();
+    window.history.replaceState({ id }, "", url);
+    this.currentStateId = id;
+    this.entries.set(id, { state, scrollY: 0 });
+    this.scrollTop = 0;
+    this.log.info("replaceState", state, url, id);
+  }
+  pushState(state, url) {
+    const id = generateUuid();
+    window.history.pushState({ id }, "", url);
+    this.currentStateId = id;
+    this.entries.set(id, { state, scrollY: 0 });
+    this.scrollTop = 0;
+    this.log.info("pushState", state, url, id);
+  }
+  beforeTransition() {
+    const { state } = window.history;
+    if (!state) return;
+    const oldEntry = this.entries.get(state.id);
+    if (!oldEntry) {
+      this.log.info(
+        "current history state evicted from LRU, not saving scroll position"
+      );
+      return;
+    }
+    const { scrollTop } = this;
+    this.entries.set(state.id, { ...oldEntry, scrollY: scrollTop });
+    this.log.info("saving scroll position", scrollTop);
+  }
+  onPopState(listener) {
+    window.addEventListener("popstate", (event) => {
+      this.currentStateId = event.state?.id;
+      if (!this.currentStateId) {
+        this.log.warn(
+          "encountered a null event.state.id in onPopState event:",
+          window.location.href
+        );
+      }
+      this.log.info("popstate", this.entries, this.currentStateId);
+      const entry = this.currentStateId ? this.entries.get(this.currentStateId) : void 0;
+      listener(window.location.href, entry?.state);
+      if (!entry) {
+        return;
+      }
+      const { scrollY } = entry;
+      this.log.info("restoring scroll to", scrollY);
+      tryScroll(this.log, () => this.getScrollablePageElement(), scrollY);
+    });
+  }
+  updateState(update) {
+    if (!this.currentStateId) {
+      this.log.warn(
+        "failed: encountered a null currentStateId inside updateState"
+      );
+      return;
+    }
+    const currentState = this.entries.get(this.currentStateId);
+    const newState = update(currentState?.state);
+    this.log.info("updateState", newState, this.currentStateId);
+    this.entries.set(this.currentStateId, {
+      ...currentState,
+      state: newState
+    });
+  }
+  get scrollTop() {
+    return this.getScrollablePageElement()?.scrollTop || 0;
+  }
+  set scrollTop(scrollTop) {
+    const element = this.getScrollablePageElement();
+    if (element) {
+      element.scrollTop = scrollTop;
+    }
+  }
+};
+
+// ../browser/src/action-handlers/flow-action.ts
+function registerFlowActionHandler(deps) {
+  const { framework, log, callbacks, updateApp } = deps;
+  let isFirstPage = true;
+  const history = new History(log, {
+    getScrollablePageElement: () => document.getElementById("scrollable-page-override") || document.getElementById("scrollable-page") || document.documentElement
+  });
+  framework.onAction(ACTION_KINDS.FLOW, async (action) => {
+    const flowAction = action;
+    const url = flowAction.url;
+    log.debug(`FlowAction \u2192 ${url}`);
+    if (flowAction.presentationContext === "modal") {
+      const match2 = framework.routeUrl(url);
+      if (match2) {
+        const page = await framework.dispatch(
+          match2.intent
+        );
+        callbacks.onModal(page);
+      }
+      return;
+    }
+    const shouldReplace = isFirstPage;
+    const match = framework.routeUrl(url);
+    if (!match) {
+      log.warn(`FlowAction: no route for ${url}`);
+      return;
+    }
+    const pagePromise = framework.dispatch(
+      match.intent
+    );
+    await Promise.race([
+      pagePromise,
+      new Promise((r) => setTimeout(r, 500))
+    ]).catch(() => {
+    });
+    history.beforeTransition();
+    updateApp({
+      page: pagePromise.then((page) => {
+        const canonicalURL = url;
+        if (shouldReplace) {
+          history.replaceState({ page }, canonicalURL);
+        } else {
+          history.pushState({ page }, canonicalURL);
+        }
+        callbacks.onNavigate(
+          new URL(canonicalURL, window.location.origin).pathname
+        );
+        didEnterPage(page);
+        return page;
+      }),
+      isFirstPage
+    });
+    isFirstPage = false;
+  });
+  history.onPopState(async (url, cachedState) => {
+    log.debug(`popstate \u2192 ${url}, cached=${!!cachedState}`);
+    callbacks.onNavigate(new URL(url).pathname);
+    if (cachedState) {
+      const { page } = cachedState;
+      didEnterPage(page);
+      updateApp({ page, isFirstPage });
+      return;
+    }
+    const parsed = new URL(url);
+    const routeMatch = framework.routeUrl(parsed.pathname + parsed.search);
+    if (!routeMatch) {
+      log.error(
+        "received popstate without data, but URL was unroutable:",
+        url
+      );
+      didEnterPage(null);
+      updateApp({
+        page: Promise.reject(new Error("404")),
+        isFirstPage
+      });
+      return;
+    }
+    const pagePromise = framework.dispatch(
+      routeMatch.intent
+    );
+    await Promise.race([
+      pagePromise,
+      new Promise((r) => setTimeout(r, 500))
+    ]).catch(() => {
+    });
+    updateApp({
+      page: pagePromise.then((page) => {
+        didEnterPage(page);
+        return page;
+      }),
+      isFirstPage
+    });
+  });
+  function didEnterPage(page) {
+    (async () => {
+      try {
+        if (page) {
+          await framework.didEnterPage(page);
+        }
+      } catch (e) {
+        log.error("didEnterPage error:", e);
+      }
+    })();
+  }
+}
+
+// ../browser/src/action-handlers/register.ts
+function registerActionHandlers(deps) {
+  const { framework, log, callbacks, updateApp } = deps;
+  registerFlowActionHandler({
+    framework,
+    log,
+    callbacks,
+    updateApp
+  });
+  registerExternalUrlHandler({ framework, log });
+}
+
+// ../browser/src/server-data.ts
+var SERVER_DATA_ID = "serialized-server-data";
+function deserializeServerData() {
+  const script = document.getElementById(SERVER_DATA_ID);
+  if (!script?.textContent) return void 0;
+  script.parentNode?.removeChild(script);
+  try {
+    return JSON.parse(script.textContent);
+  } catch {
+    return void 0;
+  }
+}
+function createPrefetchedIntentsFromDom() {
+  const data = deserializeServerData();
+  if (!data || !Array.isArray(data)) {
+    return PrefetchedIntents.empty();
+  }
+  return PrefetchedIntents.fromArray(data);
+}
+
+// ../browser/src/start-app.ts
+async function startBrowserApp(config) {
+  const {
+    bootstrap,
+    defaultLocale = "en",
+    mountId = "app",
+    mount,
+    callbacks
+  } = config;
+  const prefetchedIntents = createPrefetchedIntentsFromDom();
+  const framework = Framework.create({ prefetchedIntents });
+  bootstrap(framework);
+  const loggerFactory = framework.container.resolve(
+    DEP_KEYS.LOGGER_FACTORY
+  );
+  const log = loggerFactory.loggerFor("browser");
+  const initialAction = framework.routeUrl(
+    window.location.pathname + window.location.search
+  );
+  const locale = document.documentElement.lang || defaultLocale;
+  const target = document.getElementById(mountId);
+  const updateApp = mount(target, { framework, locale });
+  registerActionHandlers({
+    framework,
+    log,
+    callbacks,
+    updateApp
+  });
+  if (initialAction) {
+    await framework.perform(initialAction.action);
+  } else {
+    updateApp({
+      page: Promise.reject(new Error("404")),
+      isFirstPage: true
+    });
+  }
+}
+
+export {
+  ACTION_KINDS,
+  isFlowAction,
+  isExternalUrlAction,
+  isCompoundAction,
+  makeFlowAction,
+  makeExternalUrlAction,
+  ActionDispatcher,
+  IntentDispatcher,
+  Container,
+  BaseLogger,
+  shouldLog,
+  resetFilterCache,
+  ConsoleLogger,
+  ConsoleLoggerFactory,
+  DEP_KEYS,
+  makeDependencies,
+  Router,
+  CompositeLoggerFactory,
+  CompositeLogger,
+  stableStringify,
+  PrefetchedIntents,
+  Framework,
+  HttpError,
+  HttpClient,
+  BaseController,
+  pipe,
+  pipeAsync,
+  mapEach,
+  defineRoutes,
+  LruMap,
+  isSome,
+  isNone,
+  removeScheme,
+  removeHost,
+  removeQueryParams,
+  getBaseUrl,
+  buildUrl,
+  generateUuid,
+  registerExternalUrlHandler,
+  tryScroll,
+  History,
+  registerFlowActionHandler,
+  registerActionHandlers,
+  deserializeServerData,
+  createPrefetchedIntentsFromDom,
+  startBrowserApp
+};
+//# sourceMappingURL=chunk-OVGQ4NUA.js.map