@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.30

package/chunk-G5CLUK4Y.js

@@ -0,0 +1,621 @@
+import { getPathString, mergeStringPaths, getParamsAndTestPath, resolvePath } from './chunk-GYWRAW3Y.js';
+import { createContext, useContext, useState, useEffect, useMemo, useRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/app/utils/easy-layout/computeTracks.ts
+var computeTrackPixels = ({
+  tracks,
+  totalPx,
+  gapPx = 0,
+  paddingPx = 0
+}) => {
+  if (!tracks.length) {
+    return [];
+  }
+  const gapsPx = Math.max(0, tracks.length - 1) * Math.max(0, gapPx);
+  const usablePx = Math.max(0, totalPx - Math.max(0, paddingPx) * 2 - gapsPx);
+  let fixedPx = 0;
+  let frTotal = 0;
+  for (const track of tracks) {
+    if (track.kind === "px") {
+      fixedPx += track.value;
+    } else if (track.kind === "pct") {
+      fixedPx += usablePx * track.value / 100;
+    } else {
+      frTotal += track.value;
+    }
+  }
+  const remainderPx = Math.max(0, usablePx - fixedPx);
+  return tracks.map((track) => {
+    if (track.kind === "px") {
+      return track.value;
+    }
+    if (track.kind === "pct") {
+      return usablePx * track.value / 100;
+    }
+    if (frTotal <= 0) {
+      return 0;
+    }
+    return remainderPx * track.value / frTotal;
+  });
+};
+
+// 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(path, { replaceSearch: true });
+    },
+    replace: (path) => {
+      history.replace(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 targetPath = parseHistoryPath(path).path;
+      if (targetPath === (WINDOW.location?.pathname ?? "")) {
+        return;
+      }
+      WINDOW.history.pushState({}, title, path);
+      notify();
+    },
+    replace: (path, title = "") => {
+      if (!WINDOW?.history?.replaceState) {
+        return;
+      }
+      const targetPath = parseHistoryPath(path).path;
+      if (targetPath === (WINDOW.location?.pathname ?? "")) {
+        return;
+      }
+      WINDOW.history.replaceState({}, title, path);
+      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) => {
+      if (parseHistoryPath(path).path === history.location.path) {
+        return;
+      }
+      adapter.push?.(path, title);
+    },
+    replace: (path, title) => {
+      if (parseHistoryPath(path).path === history.location.path) {
+        return;
+      }
+      adapter.replace?.(path, 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(path),
+    replace: (path) => updatePath(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 RouteContext = createContext({
+  currentWindowPath: "",
+  parentPath: "",
+  params: {},
+  isTopLevel: true
+});
+var {
+  /**
+   * @ignore
+   */
+  Provider: RouteContextProvider,
+  /**
+   * @ignore
+   */
+  Consumer: RouteContextConsumer
+} = RouteContext;
+var useRouteContext = () => useContext(RouteContext);
+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 = resolvePath(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 [currentPath, setCurrentPath] = useState(
+    initialPath ?? adapter.getPath()
+  );
+  useEffect(() => {
+    return adapter.subscribe((nextPath) => {
+      setCurrentPath(nextPath);
+    });
+  }, [adapter]);
+  const contextValue = useMemo(
+    () => ({
+      currentWindowPath: currentPath,
+      parentPath: "",
+      params: {},
+      isTopLevel: true,
+      adapter
+    }),
+    [currentPath, adapter]
+  );
+  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 = "",
+    params: parentParams = {},
+    adapter
+  } = useRouteContext();
+  const targetCurrentPath = useMemo(
+    () => currentWindowPath,
+    [currentWindowPath]
+  );
+  const fullPath = useMemo(
+    () => mergeStringPaths(parentPath, path),
+    [parentPath, path]
+  );
+  const newParams = useMemo(
+    () => getParamsAndTestPath(targetCurrentPath, fullPath, exact),
+    [targetCurrentPath, fullPath, exact]
+  );
+  const params = useMemo(
+    () => ({
+      ...parentParams,
+      ...newParams ? newParams : {}
+    }),
+    [parentParams, newParams]
+  );
+  const newRouteContext = useMemo(
+    () => ({
+      currentWindowPath: targetCurrentPath,
+      parentPath: fullPath,
+      params,
+      isTopLevel: false,
+      adapter
+    }),
+    [targetCurrentPath, fullPath, params, adapter]
+  );
+  useEffect(() => {
+    if (onParamsChange) {
+      onParamsChange(params);
+    }
+  }, [params, onParamsChange]);
+  return 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;
+};
+
+export { Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeTrackPixels, createBrowserRouteAdapter, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, parseHistoryPath, useRouteContext };

package/chunk-GYWRAW3Y.js

@@ -0,0 +1,78 @@
+// src/common/Routing.ts
+var PATH_DELIMITER = "/";
+var getPotentialJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return value;
+  }
+};
+var getPathArray = (path, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriDecodeParts = true) => path.split(delimiter).filter(filterEmptyInput ? (p) => p !== "" : () => true).map(uriDecodeParts ? decodeURIComponent : (x) => x).map(useJson ? getPotentialJSONValue : (p) => p).filter(filterEmptyOutput ? (p) => p ?? false : () => true);
+var getPathString = (parts = [], delimiter = PATH_DELIMITER, filterEmptyInput = false, useJson = true, uriEncodeParts = false) => parts.filter(filterEmptyInput ? (p) => p ?? false : () => true).map(useJson ? (p) => JSON.stringify(p) : (x) => x).map(uriEncodeParts ? encodeURIComponent : (x) => x).join(delimiter);
+var mergeStringPaths = (path1, path2, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriEncodeParts = false) => getPathString(
+  [
+    ...getPathArray(
+      path1,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    ),
+    ...getPathArray(
+      path2,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    )
+  ],
+  delimiter,
+  filterEmptyInput,
+  useJson,
+  uriEncodeParts
+);
+var resolvePath = (currentPath, newPath) => {
+  const newSegments = getPathArray(newPath, PATH_DELIMITER, true);
+  let currentSegments = getPathArray(currentPath, PATH_DELIMITER, true);
+  if (newPath.startsWith("/")) {
+    currentSegments = [];
+  }
+  newSegments.forEach((segment) => {
+    if (segment === "..") {
+      if (currentSegments.length > 0) {
+        currentSegments.pop();
+      }
+    } else if (segment !== ".") {
+      currentSegments.push(segment);
+    }
+  });
+  return "/" + currentSegments.join("/");
+};
+var getParamsAndTestPath = (path, testPath, exact = false) => {
+  const pathList = getPathArray(path);
+  const testPathList = getPathArray(testPath);
+  if (exact && pathList.length !== testPathList.length) {
+    return false;
+  } else {
+    let params = {};
+    if (pathList.length >= testPathList.length) {
+      for (let i = 0; i < testPathList.length; i++) {
+        const testPathPart = testPathList[i];
+        const pathPart = pathList[i];
+        if (testPathPart.startsWith(":")) {
+          const paramName = testPathPart.slice(1);
+          params[paramName] = pathPart;
+        } else if (pathPart !== testPathPart) {
+          return false;
+        }
+      }
+    } else {
+      return false;
+    }
+    return params;
+  }
+};
+
+export { PATH_DELIMITER, getParamsAndTestPath, getPathArray, getPathString, getPotentialJSONValue, mergeStringPaths, resolvePath };