@resistdesign/voltra 3.0.0-alpha.2 → 3.0.0-alpha.20

package/app/index.js

@@ -0,0 +1,1386 @@
+import { createContext, useContext, useRef, useMemo, useCallback, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/app/utils/ApplicationState.tsx
+var getApplicationStateIdentifier = (subStateIdMap) => subStateIdMap ? subStateIdMap : {};
+var getApplicationStateModified = (identifier, modificationState) => !!modificationState.get(identifier);
+var getApplicationStateValue = (identifier, applicationState) => applicationState.get(identifier);
+var setApplicationStateModified = (identifier, value, modificationState) => new Map(modificationState).set(identifier, value);
+var setApplicationStateValue = (identifier, value, applicationState) => new Map(applicationState).set(identifier, value);
+var getApplicationStateValueStructure = (idStructure, applicationState) => Object.keys(idStructure).reduce(
+  (acc, k) => ({
+    ...acc,
+    [k]: getApplicationStateValue(idStructure[k], applicationState)
+  }),
+  {}
+);
+var ApplicationStateContext = createContext({
+  modified: /* @__PURE__ */ new Map(),
+  value: /* @__PURE__ */ new Map(),
+  onChange: () => {
+  },
+  setModified: () => {
+  }
+});
+var { Provider } = ApplicationStateContext;
+var useApplicationStateValue = (identifier) => {
+  const {
+    modified: modificationState,
+    value: applicationState,
+    onChange: setApplicationState,
+    setModified: setModificationState
+  } = useContext(ApplicationStateContext);
+  const appStateRef = useRef(applicationState);
+  appStateRef.current = applicationState;
+  const modified = useMemo(
+    () => getApplicationStateModified(identifier, modificationState),
+    [identifier, modificationState]
+  );
+  const value = useMemo(
+    () => getApplicationStateValue(identifier, applicationState),
+    [identifier, applicationState]
+  );
+  const setModified = useCallback(
+    (isModified) => {
+      setModificationState(
+        setApplicationStateModified(identifier, isModified, modificationState)
+      );
+    },
+    [identifier, setModificationState]
+  );
+  const onChange = useCallback(
+    (newValue) => {
+      setApplicationState(
+        setApplicationStateValue(identifier, newValue, appStateRef.current)
+      );
+      setModified(true);
+    },
+    [identifier, setApplicationState]
+  );
+  const controller = useMemo(
+    () => ({
+      modified,
+      value,
+      onChange,
+      setModified
+    }),
+    [modified, onChange, setModified, value]
+  );
+  return controller;
+};
+var useApplicationStateValueStructure = (idStructure) => {
+  const { value: applicationState, onChange: setApplicationState } = useContext(
+    ApplicationStateContext
+  );
+  const valueStructure = useMemo(
+    () => getApplicationStateValueStructure(idStructure, applicationState),
+    [applicationState, idStructure]
+  );
+  const onChangeStructure = useMemo(
+    () => Object.keys(idStructure).reduce(
+      (acc, k) => ({
+        ...acc,
+        [k]: (newValue) => {
+          setApplicationState(
+            setApplicationStateValue(
+              idStructure[k],
+              newValue,
+              applicationState
+            )
+          );
+        }
+      }),
+      {}
+    ),
+    [applicationState, idStructure, setApplicationState]
+  );
+  const controller = useMemo(
+    () => ({
+      valueStructure,
+      onChangeStructure
+    }),
+    [onChangeStructure, valueStructure]
+  );
+  return controller;
+};
+var ApplicationStateProvider = ({
+  children
+}) => {
+  const [modified, setModified] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [value, setValue] = useState(/* @__PURE__ */ new Map());
+  const controller = useMemo(
+    () => ({
+      modified,
+      value,
+      onChange: setValue,
+      setModified
+    }),
+    [modified, value]
+  );
+  return /* @__PURE__ */ jsx(Provider, { value: controller, children });
+};
+
+// 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 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;
+  }
+};
+
+// src/app/utils/Service.ts
+var getFullUrl = (protocol, domain, basePath = "", path = "", port) => {
+  const portString = !!port ? `:${port}` : "";
+  const fullPath = mergeStringPaths(
+    basePath,
+    path,
+    PATH_DELIMITER,
+    false,
+    false,
+    false
+  );
+  return `${protocol}://${domain}${portString}${fullPath}`;
+};
+var sendServiceRequest = async (config, path = "", args = []) => {
+  const { protocol, domain, port, basePath = "", authorization = "" } = config;
+  const fullUrl = getFullUrl(protocol, domain, basePath, path, port);
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    ...!!authorization ? {
+      Authorization: `Bearer ${authorization}`
+    } : {}
+  };
+  const response = await fetch(fullUrl, {
+    headers: requestHeaders,
+    credentials: "same-origin",
+    method: "POST",
+    body: JSON.stringify(args)
+  });
+  const { ok: responseIsOk } = response;
+  const data = await response.json();
+  if (responseIsOk) {
+    return data;
+  } else {
+    throw data;
+  }
+};
+var useApplicationStateLoader = (config) => {
+  const {
+    identifier,
+    remoteProcedureCall,
+    resetOnError = false,
+    onLoadComplete,
+    manual = false
+  } = config;
+  const { args = [] } = remoteProcedureCall;
+  const argsRef = useRef(args);
+  argsRef.current = args;
+  const [cacheValidity, setCacheValidity] = useState({});
+  const [loading, setLoading] = useState(false);
+  const [latestError, setLatestError] = useState();
+  const { onChange, setModified } = useApplicationStateValue(identifier);
+  const invalidate = useCallback(() => {
+    setCacheValidity({});
+  }, []);
+  const makeRemoteProcedureCall = useCallback(
+    async (...directArgs) => {
+      let success;
+      setLoading(true);
+      setLatestError(void 0);
+      try {
+        const { serviceConfig, path } = remoteProcedureCall;
+        const result = await sendServiceRequest(
+          serviceConfig,
+          path,
+          directArgs
+        );
+        success = true;
+        onChange(result);
+        setModified(false);
+      } catch (error) {
+        success = false;
+        setLatestError(error);
+        if (resetOnError) {
+          onChange(void 0);
+          setModified(false);
+        }
+      }
+      setLoading(false);
+      onLoadComplete?.(success);
+    },
+    [remoteProcedureCall, onChange, setModified, resetOnError, onLoadComplete]
+  );
+  const appStateLoader = useMemo(
+    () => ({
+      loading,
+      latestError,
+      invalidate,
+      makeRemoteProcedureCall
+    }),
+    [loading, latestError, invalidate, makeRemoteProcedureCall]
+  );
+  useEffect(() => {
+    if (!manual && argsRef.current) {
+      makeRemoteProcedureCall(...argsRef.current);
+    }
+  }, [cacheValidity, manual, makeRemoteProcedureCall]);
+  return appStateLoader;
+};
+var getKeyValueWithoutError = (obj, key) => {
+  try {
+    return obj[key];
+  } catch (e) {
+    return void 0;
+  }
+};
+var useController = (parentValue, key, onParentValueChange, isArrayIndex = false) => {
+  const [value, setValue] = useState(getKeyValueWithoutError(parentValue, key));
+  const onChange = useCallback(
+    (value2) => {
+      try {
+        setValue(value2);
+        if (isArrayIndex) {
+          const newArray = [...parentValue];
+          newArray[key] = value2;
+          onParentValueChange(newArray);
+        } else {
+          onParentValueChange({
+            ...parentValue,
+            [key]: value2
+          });
+        }
+      } catch (e) {
+      }
+    },
+    [parentValue, key, onParentValueChange, isArrayIndex]
+  );
+  useEffect(() => {
+    try {
+      setValue(getKeyValueWithoutError(parentValue, key));
+    } catch (e) {
+      setValue(void 0);
+    }
+  }, [parentValue, key]);
+  return [value, onChange];
+};
+var getChangedDependencyIndexes = (prevDeps, nextDeps) => nextDeps.map((dep, i) => dep !== prevDeps[i] ? i : null).filter((dep) => dep !== null);
+var useDebugDependencies = (dependencies) => {
+  const firstRender = useRef(true);
+  const prevDeps = useRef(dependencies);
+  useEffect(() => {
+    if (firstRender.current) {
+      firstRender.current = false;
+      return;
+    }
+    const changedDeps = getChangedDependencyIndexes(
+      prevDeps.current,
+      dependencies
+    );
+    if (changedDeps.length > 0) {
+      console.log("Changed dependencies:", changedDeps);
+    }
+    prevDeps.current = dependencies;
+  }, dependencies);
+};
+
+// 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/EasyLayout.tsx
+var getPascalCaseAreaName = (area) => {
+  return area.split("-").map((a) => a[0].toUpperCase() + a.slice(1)).join("");
+};
+var convertLayoutToCSS = (layout = "", spacing = {}) => {
+  const parsed = parseTemplate(layout);
+  validateAreas(parsed);
+  const renderTrack = (track) => {
+    if (track.kind === "px") {
+      return `${track.value}px`;
+    }
+    if (track.kind === "pct") {
+      return `${track.value}%`;
+    }
+    return `${track.value}fr`;
+  };
+  const areaRows = parsed.areaGrid.map((row) => row.join(" "));
+  const rows = parsed.rowTracks.map(renderTrack);
+  let css = "";
+  if (parsed.colTracks.length) {
+    css += `
+grid-template-columns: ${parsed.colTracks.map(renderTrack).join(" ")};`;
+  }
+  css += `
+grid-template-areas:
+${areaRows.map((a) => `  "${a}"`).join("\n")};`;
+  if (rows.length) {
+    css += `
+grid-template-rows: ${rows.join(" ")};`;
+  }
+  if (typeof spacing.gap !== "undefined") {
+    css += `
+gap: ${typeof spacing.gap === "number" ? `${spacing.gap}px` : spacing.gap};`;
+  }
+  if (typeof spacing.padding !== "undefined") {
+    css += `
+padding: ${typeof spacing.padding === "number" ? `${spacing.padding}px` : spacing.padding};`;
+  }
+  return {
+    areasList: parsed.areaNames,
+    css
+  };
+};
+var getEasyLayoutTemplateDetails = (layout = "", spacing = {}) => convertLayoutToCSS(layout, spacing);
+var createEasyLayout = (config, extendFrom, areasExtendFrom, spacing = {}) => {
+  return (layoutTemplate, ...expressions) => {
+    const mergedTemplate = layoutTemplate.reduce((acc, l, ind) => {
+      const expr = expressions[ind - 1];
+      const exprStr = typeof expr === "undefined" ? "" : expr;
+      return `${acc}${l}${exprStr}`;
+    }, "");
+    const { areasList, css } = convertLayoutToCSS(mergedTemplate, spacing);
+    const layout = config.createLayout({ base: extendFrom, css });
+    const areas = areasList.reduce((acc, area) => {
+      const pascalCaseAreaName = getPascalCaseAreaName(area);
+      const component = config.createArea({ base: areasExtendFrom, area });
+      return {
+        ...acc,
+        [pascalCaseAreaName]: component
+      };
+    }, {});
+    return {
+      layout,
+      areas
+    };
+  };
+};
+
+// 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 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);
+    }
+  };
+};
+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 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 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 Route = ({
+  /**
+   * 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;
+};
+
+// 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 });
+    }
+  };
+};
+
+// src/common/IdGeneration/getSimpleId.ts
+var LAST_HAST_ID = 0;
+var textEncoder = new TextEncoder();
+var bytesToBinaryString = (bytes) => {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i]);
+  }
+  return out;
+};
+var getBase64EncodedString = (input) => {
+  const bytes = textEncoder.encode(input);
+  let base64 = "";
+  if (typeof globalThis.btoa === "function") {
+    const binary = bytesToBinaryString(bytes);
+    base64 = globalThis.btoa(binary);
+  } else {
+    const anyGlobal = globalThis;
+    if (typeof anyGlobal.Buffer === "function") {
+      base64 = anyGlobal.Buffer.from(bytes).toString("base64");
+    } else {
+      throw new Error("No base64 encoder available (need btoa or Buffer).");
+    }
+  }
+  return base64;
+};
+var getSimpleId = () => {
+  const hashId = LAST_HAST_ID++;
+  const base64Datetime = getBase64EncodedString(
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const rand1 = Math.random().toString(36).substring(2, 15);
+  const rand2 = Math.random().toString(36).substring(2, 15);
+  return `${hashId}-${base64Datetime}-${rand1}-${rand2}`;
+};
+
+// src/app/utils/TypeInfoORMAPIUtils.ts
+var handleRequest = async (requestId, args, typeInfoORMAPI, methodName, onRequestStateChange) => {
+  onRequestStateChange(methodName, requestId, { loading: true });
+  try {
+    const requestMethod = typeInfoORMAPI[methodName];
+    const result = await requestMethod(...args);
+    onRequestStateChange(methodName, requestId, {
+      loading: false,
+      data: result
+    });
+  } catch (error) {
+    onRequestStateChange(methodName, requestId, {
+      loading: false,
+      error: typeof error === "object" && error !== null && "message" in error ? error.message : void 0
+    });
+  }
+};
+var requestHandlerFactory = (typeInfoORMAPI, methodName, onRequestStateChange) => (...args) => {
+  const requestId = getSimpleId();
+  handleRequest(
+    requestId,
+    args,
+    typeInfoORMAPI,
+    methodName,
+    onRequestStateChange
+  );
+  return requestId;
+};
+var useTypeInfoORMAPI = (typeInfoORMAPI) => {
+  const [state, setState] = useState({});
+  const onRequestStateChange = useCallback(
+    (methodName, requestId, { loading, data, error }) => {
+      setState(
+        ({
+          [methodName]: {
+            activeRequests: prevActiveRequests = [],
+            data: prevData,
+            error: prevError
+          } = {},
+          ...prevState
+        }) => {
+          const newActiveRequests = loading ? [...prevActiveRequests, requestId] : prevActiveRequests.filter((id) => id !== requestId);
+          const currentlyLoading = newActiveRequests.length > 0;
+          return {
+            ...prevState,
+            [methodName]: {
+              activeRequests: newActiveRequests,
+              loading: currentlyLoading,
+              data: currentlyLoading ? void 0 : data ?? prevData,
+              error: currentlyLoading ? void 0 : error ?? prevError
+            }
+          };
+        }
+      );
+    },
+    []
+  );
+  const api = useMemo(() => {
+    const apiBase = {};
+    for (const aM in typeInfoORMAPI) {
+      const methodName = aM;
+      apiBase[methodName] = requestHandlerFactory(
+        typeInfoORMAPI,
+        methodName,
+        onRequestStateChange
+      );
+    }
+    return apiBase;
+  }, [typeInfoORMAPI, onRequestStateChange]);
+  return {
+    state,
+    api
+  };
+};
+
+// src/app/utils/TypeInfoORMClient.ts
+var TypeInfoORMClient = class {
+  /**
+   * Create a client for TypeInfoORM routes.
+   *
+   * @param config - Service configuration for the API routes.
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Dispatch a request to the configured service.
+   *
+   * @param path - Route path for the ORM method.
+   * @param args - Arguments to send in the request body.
+   * @returns Parsed response payload.
+   */
+  makeRequest = async (path, args) => {
+    const cleanedArgs = [...args];
+    while (cleanedArgs.length > 0 && typeof cleanedArgs[cleanedArgs.length - 1] === "undefined") {
+      cleanedArgs.pop();
+    }
+    const result = await sendServiceRequest(this.config, path, cleanedArgs);
+    return result;
+  };
+  /**
+   * Create an item of the provided type.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param item - Item payload to persist.
+   * @returns The created item result.
+   */
+  create = async (typeName, item) => {
+    return await this.makeRequest("create" /* CREATE */, [
+      typeName,
+      item
+    ]);
+  };
+  /**
+   * Read an item by its primary field value.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param primaryFieldValue - Primary field value to lookup.
+   * @returns The retrieved item, if found.
+   */
+  read = async (typeName, primaryFieldValue, selectedFields) => {
+    return await this.makeRequest("read" /* READ */, [
+      typeName,
+      primaryFieldValue,
+      selectedFields
+    ]);
+  };
+  /**
+   * Update an item by replacing it with the provided payload.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param item - Updated item payload.
+   * @returns Whether the update succeeded.
+   */
+  update = async (typeName, item) => {
+    return await this.makeRequest("update" /* UPDATE */, [
+      typeName,
+      item
+    ]);
+  };
+  /**
+   * Delete an item by its primary field value.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param primaryFieldValue - Primary field value to delete.
+   * @returns Whether the delete succeeded.
+   */
+  delete = async (typeName, primaryFieldValue) => {
+    return await this.makeRequest("delete" /* DELETE */, [
+      typeName,
+      primaryFieldValue
+    ]);
+  };
+  /**
+   * List items for a given type.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param config - List configuration including filters and paging.
+   * @param selectedFields - Optional fields to project.
+   * @returns List results for the query.
+   */
+  list = async (typeName, config, selectedFields) => {
+    return await this.makeRequest("list" /* LIST */, [
+      typeName,
+      config,
+      selectedFields
+    ]);
+  };
+  /**
+   * Create a relationship between items.
+   *
+   * @param relationshipItem - Relationship payload.
+   * @returns Whether the relationship was created.
+   */
+  createRelationship = async (relationshipItem) => {
+    return await this.makeRequest(
+      "create-relationship" /* CREATE_RELATIONSHIP */,
+      [relationshipItem]
+    );
+  };
+  /**
+   * Delete a relationship between items.
+   *
+   * @param relationshipItem - Relationship payload.
+   * @returns Results describing the deletion.
+   */
+  deleteRelationship = async (relationshipItem) => {
+    return await this.makeRequest(
+      "delete-relationship" /* DELETE_RELATIONSHIP */,
+      [relationshipItem]
+    );
+  };
+  /**
+   * List relationship records matching the query.
+   *
+   * @param config - Relationship list query configuration.
+   * @returns Relationship list results.
+   */
+  listRelationships = async (config) => {
+    return await this.makeRequest("list-relationships" /* LIST_RELATIONSHIPS */, [
+      config
+    ]);
+  };
+  /**
+   * List related items for a relationship query.
+   *
+   * @param config - Relationship list query configuration.
+   * @param selectedFields - Optional fields to project on related items.
+   * @returns Related item list results.
+   */
+  listRelatedItems = async (config, selectedFields) => {
+    return await this.makeRequest("list-related-items" /* LIST_RELATED_ITEMS */, [
+      config,
+      selectedFields
+    ]);
+  };
+};
+
+// 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
+  };
+};
+
+// src/app/forms/core/createAutoField.ts
+var createAutoField = (suite) => {
+  return (props) => {
+    const { field, fieldKey, value, onChange, error, disabled } = props;
+    const { tags } = field;
+    const context = {
+      field,
+      fieldKey,
+      label: tags?.label ?? fieldKey,
+      required: !field.optional,
+      disabled: !!disabled,
+      error,
+      value,
+      onChange,
+      constraints: tags?.constraints,
+      format: tags?.format,
+      possibleValues: field.possibleValues,
+      allowCustomSelection: tags?.allowCustomSelection,
+      customType: tags?.customType,
+      onRelationAction: props.onRelationAction,
+      onCustomTypeAction: props.onCustomTypeAction
+    };
+    const kind = getFieldKind(field);
+    return suite.renderers[kind](context);
+  };
+};
+
+// src/app/forms/core/createFormRenderer.ts
+var createFormRenderer = (options) => {
+  const resolvedSuite = resolveSuite(
+    options.suite,
+    options.fallbackSuite
+  );
+  const AutoField = createAutoField(resolvedSuite);
+  return {
+    AutoField,
+    suite: resolvedSuite
+  };
+};
+
+// src/app/forms/core/mergeSuites.ts
+var mergeSuites = (base, overrides) => {
+  return {
+    renderers: {
+      ...base.renderers ?? {},
+      ...overrides.renderers ?? {}
+    },
+    primitives: {
+      ...base.primitives ?? {},
+      ...overrides.primitives ?? {}
+    }
+  };
+};
+var withRendererOverride = (kind, renderer) => ({
+  renderers: {
+    [kind]: renderer
+  }
+});
+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 useFormEngine = (initialValues = {}, typeInfo, options) => {
+  const operation = options?.operation ?? "CREATE" /* CREATE */;
+  const [values, setValues] = useState(
+    buildInitialValues(initialValues, typeInfo)
+  );
+  const [errors, setErrors] = useState({});
+  const setFieldValue = useCallback((path, value) => {
+    setValues((prev) => {
+      return {
+        ...prev,
+        [path]: value
+      };
+    });
+  }, []);
+  const validate = useCallback(() => {
+    const newErrors = {};
+    for (const [key, field] of Object.entries(typeInfo.fields ?? {})) {
+      if (field.tags?.hidden) {
+        continue;
+      }
+      const val = values[key];
+      if (field.readonly && (val === void 0 || val === null || val === "")) {
+        continue;
+      }
+      const isMissing = val === void 0 || val === null || val === "" || field.array && (!Array.isArray(val) || val.length === 0);
+      if (!field.optional && isMissing) {
+        newErrors[key] = "This field is required";
+        continue;
+      }
+      if (isMissing) {
+        continue;
+      }
+      const constraints = field.tags?.constraints;
+      if (constraints?.pattern && typeof val === "string") {
+        const pattern = new RegExp(constraints.pattern);
+        if (!pattern.test(val)) {
+          newErrors[key] = "Value does not match required pattern";
+          continue;
+        }
+      }
+      if (field.type === "number" && typeof val === "number") {
+        if (constraints?.min !== void 0 && val < constraints.min) {
+          newErrors[key] = `Value must be at least ${constraints.min}`;
+          continue;
+        }
+        if (constraints?.max !== void 0 && val > constraints.max) {
+          newErrors[key] = `Value must be at most ${constraints.max}`;
+          continue;
+        }
+      }
+    }
+    setErrors(newErrors);
+    return Object.keys(newErrors).length === 0;
+  }, [typeInfo, values]);
+  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: errors[key]
+      };
+    });
+  }, [typeInfo, values, errors, setFieldValue, operation]);
+  return {
+    typeInfo,
+    typeTags: typeInfo.tags,
+    operation,
+    values,
+    errors,
+    fields,
+    setFieldValue,
+    validate,
+    setErrors
+  };
+};
+
+export { ApplicationStateContext, ApplicationStateProvider, Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, TypeInfoORMClient, buildHistoryPath, buildQueryString, buildRoutePath, computeAreaBounds, computeTrackPixels, createAutoField, createEasyLayout, createFormRenderer, createManualRouteAdapter, createMemoryHistory, createRouteAdapterFromHistory, getApplicationStateIdentifier, getApplicationStateModified, getApplicationStateValue, getApplicationStateValueStructure, getChangedDependencyIndexes, getEasyLayoutTemplateDetails, getFieldKind, getFullUrl, getPascalCaseAreaName, handleRequest, mergeSuites, parseHistoryPath, parseTemplate, requestHandlerFactory, resolveSuite, sendServiceRequest, setApplicationStateModified, setApplicationStateValue, useApplicationStateLoader, useApplicationStateValue, useApplicationStateValueStructure, useController, useDebugDependencies, useFormEngine, useRouteContext, useTypeInfoORMAPI, validateAreas, withRendererOverride };