@resistdesign/voltra 3.0.0-alpha.5 → 3.0.0-alpha.51

package/chunk-K4R2PFNG.js

@@ -0,0 +1,1258 @@
+import { getErrorDescriptor, getNoErrorDescriptor, validateTypeInfoDataItem, getArrayItemErrorMap, getErrorDescriptors, ERROR_MESSAGE_CONSTANTS } from './chunk-3HVYVX3S.js';
+import { resolveRouteAdapterPath, getPathString, mergeStringPaths, getParamsAndTestPath, getPathArray, PATH_DELIMITER } from './chunk-2JDOM6PB.js';
+import { createContext, useContext, useMemo, useState, useEffect, useCallback, createElement, useRef } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/app/utils/easy-layout/parseTemplate.ts
+var parseTrackSpec = (token) => {
+  const trimmed = token.trim();
+  const numericMatch = trimmed.match(/^([0-9]*\.?[0-9]+)(fr|px|%)$/);
+  if (!numericMatch) {
+    throw new Error(
+      `Invalid track token "${trimmed}". Supported units are fr, px, and %.`
+    );
+  }
+  const value = Number(numericMatch[1]);
+  const suffix = numericMatch[2];
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`Track value must be a non-negative number. Received "${trimmed}".`);
+  }
+  if (suffix === "fr") {
+    return { kind: "fr", value };
+  }
+  if (suffix === "px") {
+    return { kind: "px", value };
+  }
+  return { kind: "pct", value };
+};
+var normalizeAreas = (areaPart) => {
+  return areaPart.trim().split(/\s+/g).map((token) => token.trim()).filter(Boolean);
+};
+var parseTemplate = (template = "") => {
+  const lines = template.split("\n").map((line) => line.trim()).filter(Boolean);
+  const areaGrid = [];
+  const rowTracks = [];
+  let colTracks = null;
+  for (const line of lines) {
+    if (line.startsWith("\\")) {
+      if (colTracks) {
+        throw new Error("Template can include only one column-track line.");
+      }
+      const colTokens = line.replace(/\\/g, " ").trim().split(/\s+/g).filter(Boolean);
+      colTracks = colTokens.map(parseTrackSpec);
+      continue;
+    }
+    const parts = line.split(",").map((part) => part.trim());
+    const areaPart = parts[0] || "";
+    if (!areaPart) {
+      continue;
+    }
+    if (parts.length > 2) {
+      throw new Error(
+        `Invalid row definition "${line}". Expected "<areas>, <row-track>".`
+      );
+    }
+    const areas = normalizeAreas(areaPart);
+    if (!areas.length) {
+      continue;
+    }
+    areaGrid.push(areas);
+    const rowTrack = parts[1];
+    if (rowTrack) {
+      rowTracks.push(parseTrackSpec(rowTrack));
+    }
+  }
+  if (!areaGrid.length) {
+    throw new Error("Template must include at least one area row.");
+  }
+  const expectedWidth = areaGrid[0].length;
+  for (let rowIndex = 0; rowIndex < areaGrid.length; rowIndex++) {
+    const width = areaGrid[rowIndex].length;
+    if (width !== expectedWidth) {
+      throw new Error(
+        `All area rows must have the same width. Expected ${expectedWidth}, received ${width} at row ${rowIndex + 1}.`
+      );
+    }
+  }
+  if (colTracks && colTracks.length !== expectedWidth) {
+    throw new Error(
+      `Column track count must match area width. Expected ${expectedWidth}, received ${colTracks.length}.`
+    );
+  }
+  const areaNames = Array.from(
+    new Set(
+      areaGrid.flat().map((name) => name.trim()).filter((name) => !!name && name !== ".")
+    )
+  );
+  return {
+    areaGrid,
+    rowTracks,
+    colTracks: colTracks || [],
+    areaNames
+  };
+};
+
+// src/app/utils/easy-layout/computeAreaBounds.ts
+var computeAreaBounds = (parsed) => {
+  const result = {};
+  for (let rowIndex = 0; rowIndex < parsed.areaGrid.length; rowIndex++) {
+    const row = parsed.areaGrid[rowIndex];
+    for (let colIndex = 0; colIndex < row.length; colIndex++) {
+      const name = row[colIndex];
+      if (!name || name === ".") {
+        continue;
+      }
+      const row1 = rowIndex + 1;
+      const col1 = colIndex + 1;
+      const existing = result[name];
+      if (!existing) {
+        result[name] = {
+          name,
+          rowStart: row1,
+          rowEnd: row1,
+          colStart: col1,
+          colEnd: col1
+        };
+        continue;
+      }
+      existing.rowStart = Math.min(existing.rowStart, row1);
+      existing.rowEnd = Math.max(existing.rowEnd, row1);
+      existing.colStart = Math.min(existing.colStart, col1);
+      existing.colEnd = Math.max(existing.colEnd, col1);
+    }
+  }
+  return result;
+};
+
+// src/app/utils/easy-layout/validateAreas.ts
+var validateAreas = (parsed) => {
+  const bounds = computeAreaBounds(parsed);
+  for (const areaName of parsed.areaNames) {
+    const bound = bounds[areaName];
+    if (!bound) {
+      continue;
+    }
+    for (let row = bound.rowStart; row <= bound.rowEnd; row++) {
+      for (let col = bound.colStart; col <= bound.colEnd; col++) {
+        const token = parsed.areaGrid[row - 1]?.[col - 1];
+        if (token !== areaName) {
+          throw new Error(
+            `Area "${areaName}" must be a rectangle. Missing "${areaName}" at row ${row}, col ${col}.`
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/app/utils/History.ts
+var createHistoryBackHandler = (history) => {
+  return {
+    /**
+     * @returns True when back navigation was handled by history.
+     */
+    handle: () => {
+      if (history.index > 0) {
+        history.back();
+        return true;
+      }
+      return false;
+    }
+  };
+};
+var ensurePrefix = (value, prefix) => value ? value.startsWith(prefix) ? value : `${prefix}${value}` : "";
+var parseHistoryPath = (inputPath) => {
+  const raw = String(inputPath ?? "").trim();
+  if (!raw) {
+    return { path: "/" };
+  }
+  try {
+    const absoluteUrl = new URL(raw);
+    return {
+      path: absoluteUrl.pathname || "/",
+      ...absoluteUrl.search ? { search: absoluteUrl.search } : {},
+      ...absoluteUrl.hash ? { hash: absoluteUrl.hash } : {}
+    };
+  } catch (error) {
+    let target = raw;
+    let hash = "";
+    let search = "";
+    const hashIndex = target.indexOf("#");
+    if (hashIndex >= 0) {
+      hash = target.slice(hashIndex);
+      target = target.slice(0, hashIndex);
+    }
+    const searchIndex = target.indexOf("?");
+    if (searchIndex >= 0) {
+      search = target.slice(searchIndex);
+      target = target.slice(0, searchIndex);
+    }
+    const path = target ? target.startsWith("/") ? target : `/${target}` : "/";
+    return {
+      path,
+      ...search && search !== "?" ? { search } : {},
+      ...hash && hash !== "#" ? { hash } : {}
+    };
+  }
+};
+var buildHistoryPath = ({
+  path,
+  search,
+  hash
+}) => {
+  const normalizedPath = path ? path.startsWith("/") ? path : `/${path}` : "/";
+  const normalizedSearch = search ? ensurePrefix(search, "?") : "";
+  const normalizedHash = hash ? ensurePrefix(hash, "#") : "";
+  return `${normalizedPath}${normalizedSearch}${normalizedHash}`;
+};
+var getHistoryLocation = (inputPath, state, getNextKey, currentLocation, replaceSearch = false) => {
+  const parsed = parseHistoryPath(inputPath);
+  const nextSearch = typeof parsed.search === "undefined" ? replaceSearch ? void 0 : currentLocation?.search : parsed.search;
+  return {
+    path: parsed.path,
+    ...typeof nextSearch !== "undefined" ? { search: nextSearch } : {},
+    ...parsed.hash ? { hash: parsed.hash } : {},
+    ...typeof state !== "undefined" ? { state } : {},
+    key: getNextKey()
+  };
+};
+var createMemoryHistory = (initialPath = "/") => {
+  let keyCounter = 0;
+  const getNextKey = () => `h${keyCounter++}`;
+  const listeners = /* @__PURE__ */ new Set();
+  const entries = [
+    {
+      location: getHistoryLocation(
+        initialPath,
+        void 0,
+        getNextKey,
+        void 0,
+        true
+      )
+    }
+  ];
+  let currentIndex = 0;
+  const getCurrentLocation = () => entries[currentIndex].location;
+  const notify = () => {
+    const location = getCurrentLocation();
+    listeners.forEach((listener) => listener(location));
+  };
+  const push = (path, opts) => {
+    const location = getHistoryLocation(
+      path,
+      opts?.state,
+      getNextKey,
+      getCurrentLocation(),
+      opts?.replaceSearch === true
+    );
+    if (currentIndex < entries.length - 1) {
+      entries.splice(currentIndex + 1);
+    }
+    entries.push({ location });
+    currentIndex = entries.length - 1;
+    notify();
+  };
+  const replace = (path, opts) => {
+    const location = getHistoryLocation(
+      path,
+      opts?.state,
+      getNextKey,
+      getCurrentLocation(),
+      opts?.replaceSearch === true
+    );
+    entries[currentIndex] = { location };
+    notify();
+  };
+  const go = (delta) => {
+    if (!Number.isFinite(delta)) {
+      return;
+    }
+    const targetIndex = Math.max(
+      0,
+      Math.min(entries.length - 1, currentIndex + Math.trunc(delta))
+    );
+    if (targetIndex === currentIndex) {
+      return;
+    }
+    currentIndex = targetIndex;
+    notify();
+  };
+  return {
+    get location() {
+      return getCurrentLocation();
+    },
+    get length() {
+      return entries.length;
+    },
+    get index() {
+      return currentIndex;
+    },
+    push,
+    replace,
+    go,
+    back: () => go(-1),
+    forward: () => go(1),
+    listen: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+};
+
+// src/app/utils/RouteHistory.ts
+var createRouteAdapterFromHistory = (history) => {
+  return {
+    getPath: () => history.location.path,
+    subscribe: (listener) => {
+      return history.listen((location) => {
+        listener(location.path);
+      });
+    },
+    push: (path) => {
+      history.push(resolveRouteAdapterPath(history.location.path, path), {
+        replaceSearch: true
+      });
+    },
+    replace: (path) => {
+      history.replace(resolveRouteAdapterPath(history.location.path, path), {
+        replaceSearch: true
+      });
+    },
+    back: history.back,
+    canGoBack: () => history.index > 0
+  };
+};
+
+// src/app/utils/UniversalRouteAdapter.ts
+var getWindow = () => {
+  if (typeof globalThis === "undefined") {
+    return void 0;
+  }
+  if ("window" in globalThis) {
+    return globalThis.window;
+  }
+  return void 0;
+};
+var canUseBrowserHistory = () => {
+  const WINDOW = getWindow();
+  return Boolean(
+    WINDOW && WINDOW.location && WINDOW.history && typeof WINDOW.history.pushState === "function"
+  );
+};
+var createBrowserRouteAdapter = () => {
+  const WINDOW = getWindow();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    const path = WINDOW?.location?.pathname ?? "";
+    listeners.forEach((listener) => listener(path));
+  };
+  const handleHistoryEvent = () => {
+    notify();
+  };
+  return {
+    getPath: () => WINDOW?.location?.pathname ?? "",
+    subscribe: (listener) => {
+      listeners.add(listener);
+      if (WINDOW) {
+        WINDOW.addEventListener("popstate", handleHistoryEvent);
+        WINDOW.addEventListener("statechanged", handleHistoryEvent);
+      }
+      return () => {
+        listeners.delete(listener);
+        if (WINDOW) {
+          WINDOW.removeEventListener("popstate", handleHistoryEvent);
+          WINDOW.removeEventListener("statechanged", handleHistoryEvent);
+        }
+      };
+    },
+    push: (path, title = "") => {
+      if (!WINDOW?.history) {
+        return;
+      }
+      const resolvedPath = resolveRouteAdapterPath(
+        WINDOW.location?.pathname ?? "",
+        path
+      );
+      const targetPath = parseHistoryPath(resolvedPath).path;
+      if (targetPath === (WINDOW.location?.pathname ?? "")) {
+        return;
+      }
+      WINDOW.history.pushState({}, title, resolvedPath);
+      notify();
+    },
+    replace: (path, title = "") => {
+      if (!WINDOW?.history?.replaceState) {
+        return;
+      }
+      const resolvedPath = resolveRouteAdapterPath(
+        WINDOW.location?.pathname ?? "",
+        path
+      );
+      const targetPath = parseHistoryPath(resolvedPath).path;
+      if (targetPath === (WINDOW.location?.pathname ?? "")) {
+        return;
+      }
+      WINDOW.history.replaceState({}, title, resolvedPath);
+      notify();
+    },
+    back: () => WINDOW?.history?.back(),
+    canGoBack: () => (WINDOW?.history?.length ?? 0) > 1
+  };
+};
+var createNativeRouteAdapter = (initialPath = "/", ingress) => {
+  const mapURLToPath = ingress?.mapURLToPath ?? ((url) => buildHistoryPath(parseHistoryPath(url)));
+  const onIncomingURL = ingress?.onIncomingURL ?? "replace";
+  const history = createMemoryHistory(initialPath);
+  const adapter = createRouteAdapterFromHistory(history);
+  let stopIngress;
+  let ingressStarted = false;
+  let subscribers = 0;
+  const applyPath = (path, mode) => {
+    const normalizedPath = parseHistoryPath(path).path;
+    if (!normalizedPath || normalizedPath === history.location.path) {
+      return;
+    }
+    if (mode === "push") {
+      history.push(normalizedPath, { replaceSearch: true });
+      return;
+    }
+    history.replace(normalizedPath, { replaceSearch: true });
+  };
+  const startIngress = async () => {
+    if (ingressStarted || !ingress) {
+      return;
+    }
+    ingressStarted = true;
+    const startKey = history.location.key;
+    const startIndex = history.index;
+    if (ingress.subscribe) {
+      stopIngress = ingress.subscribe((url) => {
+        const nextPath = mapURLToPath(url);
+        if (!nextPath) {
+          return;
+        }
+        applyPath(nextPath, onIncomingURL);
+      });
+    }
+    const initialURL = await ingress.getInitialURL?.();
+    const userNavigated = history.location.key !== startKey || history.index !== startIndex;
+    if (!userNavigated && initialURL) {
+      const nextPath = mapURLToPath(initialURL);
+      if (nextPath) {
+        applyPath(nextPath, "replace");
+      }
+    }
+  };
+  return {
+    ...adapter,
+    push: (path, title) => {
+      const resolvedPath = resolveRouteAdapterPath(history.location.path, path);
+      if (parseHistoryPath(resolvedPath).path === history.location.path) {
+        return;
+      }
+      adapter.push?.(resolvedPath, title);
+    },
+    replace: (path, title) => {
+      const resolvedPath = resolveRouteAdapterPath(history.location.path, path);
+      if (parseHistoryPath(resolvedPath).path === history.location.path) {
+        return;
+      }
+      adapter.replace?.(resolvedPath, title);
+    },
+    subscribe: (listener) => {
+      subscribers += 1;
+      if (subscribers === 1) {
+        void startIngress();
+      }
+      const unlisten = adapter.subscribe(listener);
+      return () => {
+        unlisten();
+        subscribers = Math.max(0, subscribers - 1);
+        if (subscribers === 0) {
+          stopIngress?.();
+          stopIngress = void 0;
+          ingressStarted = false;
+        }
+      };
+    },
+    back: adapter.back,
+    canGoBack: adapter.canGoBack
+  };
+};
+var createUniversalAdapter = (options = {}) => {
+  const { strategy = "auto", initialPath = "/", ingress } = options;
+  if (strategy === "web") {
+    return createBrowserRouteAdapter();
+  }
+  if (strategy === "native") {
+    return createNativeRouteAdapter(initialPath, ingress);
+  }
+  return canUseBrowserHistory() ? createBrowserRouteAdapter() : createNativeRouteAdapter(initialPath, ingress);
+};
+var createManualRouteAdapter = (initialPath = "/") => {
+  let currentPath = initialPath;
+  const listeners = /* @__PURE__ */ new Set();
+  const updatePath = (nextPath) => {
+    currentPath = nextPath;
+    listeners.forEach((listener) => listener(nextPath));
+  };
+  const adapter = {
+    getPath: () => currentPath,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    push: (path) => updatePath(resolveRouteAdapterPath(currentPath, path)),
+    replace: (path) => updatePath(resolveRouteAdapterPath(currentPath, path))
+  };
+  return {
+    adapter,
+    updatePath
+  };
+};
+var isDevelopmentMode = () => {
+  const env = globalThis?.process?.env?.NODE_ENV;
+  return env !== "production";
+};
+var buildQueryString = (query = {}) => {
+  const parts = [];
+  for (const [key, rawValue] of Object.entries(query)) {
+    if (rawValue === void 0) {
+      continue;
+    }
+    const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+    for (const value of values) {
+      if (value === void 0) {
+        continue;
+      }
+      const encodedKey = encodeURIComponent(key);
+      const encodedValue = value === null ? "" : encodeURIComponent(String(value));
+      parts.push(`${encodedKey}=${encodedValue}`);
+    }
+  }
+  return parts.join("&");
+};
+var buildRoutePath = (segments, query) => {
+  const normalizedSegments = segments.map((segment) => String(segment));
+  const basePath = "/" + getPathString(normalizedSegments, "/", true, false, true);
+  const queryString = query ? buildQueryString(query) : "";
+  return queryString ? `${basePath}?${queryString}` : basePath;
+};
+var getReadableRoutePath = (path) => getPathString(
+  getPathArray(path, PATH_DELIMITER, true, true, true, false),
+  PATH_DELIMITER,
+  true,
+  false,
+  false
+);
+var RouteContext = createContext({
+  currentWindowPath: "",
+  parentPath: "",
+  parentPathInternal: "",
+  params: {},
+  isTopLevel: true,
+  adapterBasePath: "/"
+});
+var {
+  /**
+   * @ignore
+   */
+  Provider: RouteContextProvider,
+  /**
+   * @ignore
+   */
+  Consumer: RouteContextConsumer
+} = RouteContext;
+var useRouteContext = () => useContext(RouteContext);
+var wrapRouteAdapterWithPathResolver = (adapter, getBasePath = () => adapter.getPath()) => {
+  if (!adapter.push && !adapter.replace) {
+    return adapter;
+  }
+  const wrappedAdapter = {
+    ...adapter,
+    push: adapter.push ? (path, title) => {
+      adapter.push?.(resolveRouteAdapterPath(getBasePath(), path), title);
+    } : void 0,
+    replace: adapter.replace ? (path, title) => {
+      adapter.replace?.(resolveRouteAdapterPath(getBasePath(), path), title);
+    } : void 0
+  };
+  return wrappedAdapter;
+};
+var getAdapterBasePath = (currentPath) => {
+  const normalizedPath = String(currentPath ?? "").trim();
+  if (normalizedPath === "") {
+    return "/";
+  }
+  const [pathOnly] = normalizedPath.split(/[?#]/, 1);
+  return pathOnly || "/";
+};
+var getMatchedRouteBasePath = (currentPath, matchedRoutePath) => {
+  const currentPathSegments = getPathArray(
+    getAdapterBasePath(currentPath),
+    PATH_DELIMITER,
+    true,
+    true,
+    false,
+    false
+  );
+  const matchedRouteSegments = getPathArray(matchedRoutePath);
+  const resolvedSegments = currentPathSegments.slice(0, matchedRouteSegments.length);
+  return resolvedSegments.length > 0 ? `/${resolvedSegments.join(PATH_DELIMITER)}` : "/";
+};
+var getWindow2 = () => {
+  if (typeof globalThis === "undefined") {
+    return void 0;
+  }
+  if ("window" in globalThis) {
+    return globalThis.window;
+  }
+  return void 0;
+};
+var useBrowserLinkInterceptor = (adapter) => {
+  useEffect(() => {
+    const WINDOW = getWindow2();
+    if (!WINDOW || !adapter?.push) {
+      return void 0;
+    }
+    const handleAnchorClick = (event) => {
+      let target = event.target;
+      while (target && target.nodeName !== "A") {
+        target = target.parentNode;
+      }
+      if (!target || target.nodeName !== "A") {
+        return;
+      }
+      const anchor = target;
+      const href = anchor.getAttribute("href");
+      const title = anchor.getAttribute("title") ?? "";
+      if (!href) {
+        return;
+      }
+      try {
+        new URL(href);
+        return;
+      } catch (error) {
+        const nextPath = resolveRouteAdapterPath(
+          WINDOW.location?.pathname ?? "",
+          href
+        );
+        event.preventDefault();
+        adapter.push?.(nextPath, title);
+      }
+    };
+    WINDOW.document?.addEventListener("click", handleAnchorClick);
+    return () => {
+      WINDOW.document?.removeEventListener("click", handleAnchorClick);
+    };
+  }, [adapter]);
+};
+var RouteProvider = ({
+  adapter,
+  initialPath,
+  children
+}) => {
+  const normalizedAdapter = useMemo(
+    () => wrapRouteAdapterWithPathResolver(adapter),
+    [adapter]
+  );
+  const [currentPath, setCurrentPath] = useState(
+    initialPath ?? normalizedAdapter.getPath()
+  );
+  const adapterBasePath = useMemo(
+    () => getAdapterBasePath(currentPath),
+    [currentPath]
+  );
+  useEffect(() => {
+    return normalizedAdapter.subscribe((nextPath) => {
+      setCurrentPath(nextPath);
+    });
+  }, [normalizedAdapter]);
+  const contextValue = useMemo(
+    () => ({
+      currentWindowPath: currentPath,
+      parentPath: "",
+      parentPathInternal: "",
+      params: {},
+      isTopLevel: true,
+      adapterBasePath,
+      adapter: normalizedAdapter
+    }),
+    [currentPath, adapterBasePath, normalizedAdapter]
+  );
+  return /* @__PURE__ */ jsx(RouteContextProvider, { value: contextValue, children });
+};
+var RouteMatcher = ({
+  /**
+   * Use `:` as the first character to denote a parameter in the path.
+   */
+  path,
+  onParamsChange,
+  exact = false,
+  children
+}) => {
+  const {
+    currentWindowPath = "",
+    parentPath = "",
+    parentPathInternal = "",
+    params: parentParams = {},
+    adapterBasePath: inheritedAdapterBasePath = "/",
+    adapter
+  } = useRouteContext();
+  const targetCurrentPath = useMemo(
+    () => currentWindowPath,
+    [currentWindowPath]
+  );
+  const normalizedPaths = useMemo(() => {
+    const routePaths = Array.isArray(path) ? path : [path];
+    return routePaths.map(
+      (routePath) => typeof routePath === "string" ? {
+        path: routePath,
+        exact
+      } : routePath
+    );
+  }, [path, exact]);
+  const matchedRoute = useMemo(
+    () => {
+      for (const routePathConfig of normalizedPaths) {
+        const fullPath = mergeStringPaths(
+          parentPathInternal,
+          routePathConfig.path
+        );
+        const newParams = getParamsAndTestPath(
+          targetCurrentPath,
+          fullPath,
+          routePathConfig.exact
+        );
+        if (newParams) {
+          return {
+            fullPath,
+            newParams
+          };
+        }
+      }
+      return null;
+    },
+    [targetCurrentPath, parentPathInternal, normalizedPaths]
+  );
+  const params = useMemo(
+    () => ({
+      ...parentParams,
+      ...matchedRoute?.newParams ? matchedRoute.newParams : {}
+    }),
+    [parentParams, matchedRoute]
+  );
+  const matchedAdapterBasePath = useMemo(
+    () => matchedRoute ? getMatchedRouteBasePath(targetCurrentPath, matchedRoute.fullPath) : inheritedAdapterBasePath,
+    [targetCurrentPath, matchedRoute, inheritedAdapterBasePath]
+  );
+  const scopedAdapter = useMemo(
+    () => adapter ? wrapRouteAdapterWithPathResolver(adapter, () => matchedAdapterBasePath) : adapter,
+    [adapter, matchedAdapterBasePath]
+  );
+  const newRouteContext = useMemo(
+    () => ({
+      currentWindowPath: targetCurrentPath,
+      parentPath: getReadableRoutePath(matchedRoute?.fullPath ?? parentPathInternal),
+      parentPathInternal: matchedRoute?.fullPath ?? parentPathInternal,
+      params,
+      isTopLevel: false,
+      adapterBasePath: matchedAdapterBasePath,
+      adapter: scopedAdapter
+    }),
+    [
+      targetCurrentPath,
+      matchedRoute,
+      parentPathInternal,
+      params,
+      matchedAdapterBasePath,
+      scopedAdapter
+    ]
+  );
+  useEffect(() => {
+    if (onParamsChange) {
+      onParamsChange(params);
+    }
+  }, [params, onParamsChange]);
+  return matchedRoute?.newParams ? /* @__PURE__ */ jsx(RouteContextProvider, { value: newRouteContext, children }) : null;
+};
+var RouteRootProvider = ({
+  children,
+  adapter,
+  initialPath,
+  ingress,
+  runtimeIntegration
+}) => {
+  const routeContext = useRouteContext();
+  const autoAdapterRef = useRef(null);
+  if (typeof routeContext.adapter !== "undefined" && isDevelopmentMode()) {
+    throw new Error(
+      "Route provider mode is root-only. Nested Route requires a path."
+    );
+  }
+  if (!autoAdapterRef.current) {
+    autoAdapterRef.current = adapter ?? createUniversalAdapter({ initialPath, ingress });
+  }
+  useBrowserLinkInterceptor(autoAdapterRef.current);
+  useEffect(() => {
+    if (!runtimeIntegration || !autoAdapterRef.current) {
+      return void 0;
+    }
+    return runtimeIntegration.setup(autoAdapterRef.current);
+  }, [runtimeIntegration]);
+  return /* @__PURE__ */ jsx(RouteProvider, { adapter: autoAdapterRef.current, initialPath, children });
+};
+var Route = (props) => {
+  const hasMatcherProps = typeof props.path !== "undefined" || typeof props.exact !== "undefined" || typeof props.onParamsChange !== "undefined";
+  const hasProviderProps = typeof props.initialPath !== "undefined" || typeof props.adapter !== "undefined" || typeof props.ingress !== "undefined" || typeof props.runtimeIntegration !== "undefined";
+  if (hasMatcherProps) {
+    if (hasProviderProps && isDevelopmentMode()) {
+      throw new Error(
+        "Route matcher mode does not support provider props. Remove initialPath/adapter/ingress/runtimeIntegration or use a root Route without path."
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      RouteMatcher,
+      {
+        path: props.path ?? "",
+        onParamsChange: props.onParamsChange,
+        exact: props.exact,
+        children: props.children
+      }
+    );
+  }
+  if (typeof props.path === "undefined") {
+    return /* @__PURE__ */ jsx(
+      RouteRootProvider,
+      {
+        adapter: props.adapter,
+        initialPath: props.initialPath,
+        ingress: props.ingress,
+        runtimeIntegration: props.runtimeIntegration,
+        children: props.children
+      }
+    );
+  }
+  return null;
+};
+
+// src/app/forms/core/getFieldKind.ts
+var hasSelectableValues = (field) => {
+  const possibleValues = field.possibleValues ?? [];
+  return possibleValues.some(
+    (value) => typeof value === "string" || typeof value === "number"
+  );
+};
+var getFieldKind = (field) => {
+  if (field.typeReference) {
+    return field.array ? "relation_array" : "relation_single";
+  }
+  if (field.tags?.customType) {
+    return field.array ? "custom_array" : "custom_single";
+  }
+  if (field.array) {
+    return "array";
+  }
+  if (hasSelectableValues(field)) {
+    return "enum_select";
+  }
+  if (field.type === "boolean") {
+    return "boolean";
+  }
+  if (field.type === "number") {
+    return "number";
+  }
+  return "string";
+};
+
+// src/app/forms/core/resolveSuite.ts
+var fieldKinds = [
+  "string",
+  "number",
+  "boolean",
+  "enum_select",
+  "array",
+  "relation_single",
+  "relation_array",
+  "custom_single",
+  "custom_array"
+];
+var getMissingKinds = (renderers) => {
+  return fieldKinds.filter((kind) => !renderers[kind]);
+};
+var resolveSuite = (overrides, fallback) => {
+  const mergedRenderers = {
+    ...fallback.renderers ?? {},
+    ...overrides?.renderers ?? {}
+  };
+  const missingKinds = getMissingKinds(mergedRenderers);
+  if (missingKinds.length) {
+    throw new Error(
+      `Missing renderers for field kinds: ${missingKinds.join(", ")}`
+    );
+  }
+  const mergedPrimitives = {
+    ...fallback.primitives ?? {},
+    ...overrides?.primitives ?? {}
+  };
+  return {
+    renderers: mergedRenderers,
+    primitives: Object.keys(mergedPrimitives).length ? mergedPrimitives : void 0
+  };
+};
+var createAutoField = (suite) => {
+  const defaultTranslateValidationErrorCode2 = (error) => error.code === ERROR_MESSAGE_CONSTANTS.NONE ? "" : String(error.code);
+  const AutoField = (props) => {
+    const { field, fieldKey, value, onChange, error, disabled } = props;
+    const { tags } = field;
+    const resolvedErrors = props.errors ?? (error ? [error] : []);
+    const resolvedError = resolvedErrors.find((descriptor) => descriptor.code !== ERROR_MESSAGE_CONSTANTS.NONE) ?? getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.NONE);
+    const context = {
+      field,
+      fieldKey,
+      label: tags?.label ?? fieldKey,
+      required: !field.optional,
+      disabled: !!disabled,
+      error: resolvedError,
+      errors: resolvedErrors,
+      arrayItemErrorMap: props.arrayItemErrorMap,
+      translateValidationErrorCode: props.translateValidationErrorCode ?? defaultTranslateValidationErrorCode2,
+      value,
+      onChange,
+      constraints: tags?.constraints,
+      format: tags?.format,
+      possibleValues: field.possibleValues,
+      allowCustomSelection: tags?.allowCustomSelection,
+      customType: tags?.customType,
+      onRelationAction: props.onRelationAction,
+      onCustomTypeAction: props.onCustomTypeAction,
+      renderField: (input) => createElement(AutoField, {
+        field: input.field,
+        fieldKey: input.fieldKey,
+        value: input.value,
+        onChange: input.onChange,
+        error: input.error,
+        errors: input.errors,
+        arrayItemErrorMap: input.arrayItemErrorMap,
+        translateValidationErrorCode: input.translateValidationErrorCode,
+        disabled: input.disabled,
+        onRelationAction: input.onRelationAction,
+        onCustomTypeAction: input.onCustomTypeAction
+      })
+    };
+    const kind = getFieldKind(field);
+    return createElement(suite.renderers[kind], context);
+  };
+  return AutoField;
+};
+
+// src/app/forms/core/createFormRenderer.ts
+var createFormRenderer = (options) => {
+  const resolvedSuite = resolveSuite(
+    options.suite,
+    options.fallbackSuite
+  );
+  const AutoField = createAutoField(resolvedSuite);
+  return {
+    AutoField,
+    suite: resolvedSuite
+  };
+};
+var getDeniedOperation = (deniedOperations, operation) => {
+  if (!deniedOperations) {
+    return false;
+  }
+  const denied = deniedOperations[operation];
+  if (typeof denied === "boolean") {
+    return denied;
+  }
+  return deniedOperations[operation.toLowerCase()] ?? false;
+};
+var buildInitialValues = (initialValues, typeInfo) => {
+  const values = { ...initialValues };
+  for (const [key, field] of Object.entries(typeInfo.fields ?? {})) {
+    if (values[key] !== void 0) {
+      continue;
+    }
+    const defaultValue = field.tags?.constraints?.defaultValue;
+    if (defaultValue !== void 0) {
+      let parsedDefaultValue = defaultValue;
+      try {
+        parsedDefaultValue = JSON.parse(defaultValue);
+      } catch (error) {
+      }
+      values[key] = parsedDefaultValue;
+      continue;
+    }
+    if (field.array && !field.typeReference && !field.optional) {
+      values[key] = [];
+      continue;
+    }
+    if (field.type === "boolean" && !field.optional) {
+      values[key] = false;
+    }
+  }
+  return values;
+};
+var FORM_ENGINE_TYPE_NAME = "__AUTO_FORM__";
+var useFormEngine = (initialValues = {}, typeInfo, options) => {
+  const operation = options?.operation ?? "CREATE" /* CREATE */;
+  const customValidatorMap = options?.customValidatorMap ?? {};
+  const [values, setValues] = useState(
+    buildInitialValues(initialValues, typeInfo)
+  );
+  const [errors, setErrorsState] = useState({});
+  const normalizeErrorEntries = useCallback(
+    (value) => {
+      if (typeof value === "string") {
+        return [getErrorDescriptor(value)];
+      }
+      if (Array.isArray(value)) {
+        return value;
+      }
+      if (value && typeof value === "object") {
+        if ("code" in value && typeof value.code === "string") {
+          return [value];
+        }
+        const itemErrorMap = value;
+        const numericKeys = Object.keys(itemErrorMap).filter(
+          (key) => /^\d+$/.test(key)
+        );
+        if (numericKeys.length) {
+          const normalizedItemErrorMap = {};
+          for (const key of numericKeys) {
+            const index = Number(key);
+            const rawValue = itemErrorMap[key];
+            if (!Array.isArray(rawValue)) {
+              continue;
+            }
+            normalizedItemErrorMap[index] = rawValue.filter(
+              (descriptor) => !!descriptor && typeof descriptor === "object" && "code" in descriptor && typeof descriptor.code === "string"
+            );
+          }
+          return [{ itemErrorMap: normalizedItemErrorMap }];
+        }
+      }
+      return [getNoErrorDescriptor()];
+    },
+    []
+  );
+  const normalizeErrorMap = useCallback(
+    (pendingErrors) => Object.entries(pendingErrors).reduce((acc, [key, value]) => {
+      acc[key] = normalizeErrorEntries(value);
+      return acc;
+    }, {}),
+    [normalizeErrorEntries]
+  );
+  const setErrors = useCallback(
+    (pendingErrors) => {
+      setErrorsState(normalizeErrorMap(pendingErrors));
+    },
+    [normalizeErrorMap]
+  );
+  const setFieldValue = useCallback((path, value) => {
+    setValues((prev) => {
+      return {
+        ...prev,
+        [path]: value
+      };
+    });
+  }, []);
+  const validate = useCallback(() => {
+    const fields2 = typeInfo.fields ?? {};
+    const validationResults = validateTypeInfoDataItem(
+      values,
+      typeInfo,
+      customValidatorMap,
+      {
+        typeName: FORM_ENGINE_TYPE_NAME,
+        typeOperation: operation
+      }
+    );
+    const newErrors = {};
+    for (const key of Object.keys(fields2)) {
+      newErrors[key] = validationResults.errorMap[key] ?? [getNoErrorDescriptor()];
+    }
+    setErrorsState(newErrors);
+    return validationResults;
+  }, [typeInfo, values, operation, customValidatorMap]);
+  const fields = useMemo(() => {
+    return Object.entries(typeInfo.fields ?? {}).map(([key, field]) => {
+      const { tags } = field;
+      const isPrimary = tags?.primaryField || typeInfo.primaryField === key;
+      return {
+        key,
+        field,
+        label: tags?.label ?? key,
+        required: !field.optional,
+        disabled: field.readonly || getDeniedOperation(typeInfo.tags?.deniedOperations, operation) || getDeniedOperation(tags?.deniedOperations, operation) || operation === "UPDATE" /* UPDATE */ && isPrimary,
+        hidden: !!tags?.hidden,
+        primary: isPrimary,
+        format: tags?.format,
+        constraints: tags?.constraints,
+        value: values[key],
+        onChange: (value) => setFieldValue(key, value),
+        error: getErrorDescriptors(errors[key] ?? []).find(
+          (descriptor) => descriptor.code !== ERROR_MESSAGE_CONSTANTS.NONE
+        ) ?? getNoErrorDescriptor(),
+        errors: getErrorDescriptors(errors[key] ?? []),
+        arrayItemErrorMap: getArrayItemErrorMap(errors[key] ?? [])
+      };
+    });
+  }, [typeInfo, values, errors, setFieldValue, operation]);
+  return {
+    typeInfo,
+    typeTags: typeInfo.tags,
+    operation,
+    values,
+    errors,
+    fields,
+    setFieldValue,
+    validate,
+    setErrors
+  };
+};
+var fallbackFormRoot = ({
+  children,
+  onSubmit
+}) => {
+  const handleSubmit = (event) => {
+    event.preventDefault();
+    onSubmit?.();
+  };
+  return /* @__PURE__ */ jsx("form", { onSubmit: handleSubmit, children });
+};
+var fallbackButton = ({
+  children,
+  disabled,
+  type,
+  onClick
+}) => {
+  return /* @__PURE__ */ jsx("button", { type: type ?? "button", disabled, onClick, children });
+};
+var AutoFormView = ({
+  controller,
+  onSubmit,
+  renderer,
+  submitDisabled,
+  onRelationAction,
+  onCustomTypeAction,
+  translateValidationErrorCode = defaultTranslateValidationErrorCode
+}) => {
+  const FormRoot = renderer.suite.primitives?.FormRoot ?? fallbackFormRoot;
+  const Button = renderer.suite.primitives?.Button ?? fallbackButton;
+  const AutoField = renderer.AutoField;
+  const submit = () => {
+    const validationResults = controller.validate();
+    if (validationResults.valid) {
+      onSubmit(controller.values);
+    }
+  };
+  return /* @__PURE__ */ jsx(FormRoot, { onSubmit: submit, children: /* @__PURE__ */ jsxs(Fragment, { children: [
+    controller.fields.filter((fieldController) => !fieldController.hidden).map((fieldController) => /* @__PURE__ */ jsx(
+      AutoField,
+      {
+        field: fieldController.field,
+        fieldKey: fieldController.key,
+        value: fieldController.value,
+        onChange: fieldController.onChange,
+        error: fieldController.error,
+        errors: fieldController.errors,
+        arrayItemErrorMap: fieldController.arrayItemErrorMap,
+        translateValidationErrorCode,
+        onRelationAction,
+        disabled: fieldController.disabled,
+        onCustomTypeAction
+      },
+      fieldController.key
+    )),
+    /* @__PURE__ */ jsx(Button, { type: "submit", onClick: submit, disabled: submitDisabled, children: /* @__PURE__ */ jsx(Fragment, { children: "Submit" }) })
+  ] }) });
+};
+var defaultTranslateValidationErrorCode = (error) => {
+  const { code, values = [] } = error;
+  const [constraintValue] = values;
+  switch (code) {
+    case ERROR_MESSAGE_CONSTANTS.INVALID_CUSTOM_TYPE:
+      return "Value failed custom validation";
+    case ERROR_MESSAGE_CONSTANTS.NOT_A_STRING:
+      return "Value must be a string";
+    case ERROR_MESSAGE_CONSTANTS.NOT_A_NUMBER:
+      return "Value must be a number";
+    case ERROR_MESSAGE_CONSTANTS.NOT_A_BOOLEAN:
+      return "Value must be a boolean";
+    case ERROR_MESSAGE_CONSTANTS.DENIED_TYPE_OPERATION_CREATE:
+      return "Create operation is not allowed for this value";
+    case ERROR_MESSAGE_CONSTANTS.DENIED_TYPE_OPERATION_READ:
+      return "Read operation is not allowed for this value";
+    case ERROR_MESSAGE_CONSTANTS.DENIED_TYPE_OPERATION_UPDATE:
+      return "Update operation is not allowed for this value";
+    case ERROR_MESSAGE_CONSTANTS.DENIED_TYPE_OPERATION_DELETE:
+      return "Delete operation is not allowed for this value";
+    case ERROR_MESSAGE_CONSTANTS.MISSING_FIELD_VALUE:
+      return "This field is required";
+    case ERROR_MESSAGE_CONSTANTS.INVALID_FIELD:
+      return "This field is not allowed";
+    case ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN:
+      return "Value does not match required pattern";
+    case ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN:
+      return "Field pattern configuration is invalid";
+    case ERROR_MESSAGE_CONSTANTS.VALUE_BELOW_MINIMUM:
+      return `Value must be at least ${constraintValue ?? "the minimum"}`;
+    case ERROR_MESSAGE_CONSTANTS.VALUE_ABOVE_MAXIMUM:
+      return `Value must be at most ${constraintValue ?? "the maximum"}`;
+    case ERROR_MESSAGE_CONSTANTS.INVALID_OPTION:
+      return "Value is not one of the allowed options";
+    case ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED:
+      return "Relationship values are not allowed for this operation";
+    case ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED:
+      return "Value does not match any allowed shape";
+    case ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST:
+      return "Type definition was not found";
+    case ERROR_MESSAGE_CONSTANTS.INVALID_TYPE:
+      return "Value has an invalid type";
+    case ERROR_MESSAGE_CONSTANTS.NONE:
+      return "";
+    default:
+      return String(code);
+  }
+};
+var AutoForm = ({
+  typeInfo,
+  onSubmit,
+  renderer,
+  initialValues,
+  onValuesChange,
+  onRelationAction,
+  onCustomTypeAction,
+  operation,
+  submitDisabled,
+  translateValidationErrorCode = defaultTranslateValidationErrorCode,
+  customValidatorMap
+}) => {
+  const controller = useFormEngine(initialValues, typeInfo, {
+    operation,
+    customValidatorMap
+  });
+  useEffect(() => {
+    if (onValuesChange) {
+      onValuesChange(controller.values);
+    }
+  }, [controller.values, onValuesChange]);
+  return /* @__PURE__ */ jsx(
+    AutoFormView,
+    {
+      controller,
+      onSubmit,
+      renderer,
+      onRelationAction,
+      onCustomTypeAction,
+      submitDisabled,
+      translateValidationErrorCode
+    }
+  );
+};
+
+export { AutoForm, AutoFormView, Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeAreaBounds, createAutoField, createBrowserRouteAdapter, createFormRenderer, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, defaultTranslateValidationErrorCode, getFieldKind, parseHistoryPath, parseTemplate, resolveSuite, useFormEngine, useRouteContext, validateAreas, wrapRouteAdapterWithPathResolver };