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

package/native/index.js

@@ -0,0 +1,1323 @@
+import { createContext, useContext, createElement, useState, useEffect, useMemo, useRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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
+  };
+};
+var getNative = () => __require("react-native");
+var FieldWrapper = (props) => {
+  const { View } = getNative();
+  return createElement(View, null, props.children);
+};
+var ErrorMessage = ({ children }) => {
+  const { Text } = getNative();
+  return createElement(Text, { style: { color: "#AA0000" } }, children);
+};
+var ArrayContainer = (props) => {
+  const { View } = getNative();
+  return createElement(View, null, props.children);
+};
+var ArrayItemWrapper = (props) => {
+  const { View } = getNative();
+  return createElement(View, null, props.children);
+};
+var Button = ({
+  children,
+  disabled,
+  onPress
+}) => {
+  const { Pressable, Text } = getNative();
+  return createElement(
+    Pressable,
+    { onPress, disabled },
+    createElement(Text, null, children)
+  );
+};
+
+// src/native/forms/suite.ts
+var getNative2 = () => __require("react-native");
+var createArrayItemField = (field) => ({
+  ...field,
+  array: false,
+  tags: {
+    ...field.tags,
+    label: void 0
+  }
+});
+var parseNumberValue = (raw) => raw === "" ? null : Number(raw);
+var getSelectableValues = (possibleValues) => {
+  return possibleValues?.filter(
+    (v) => typeof v === "string" || typeof v === "number"
+  );
+};
+var formatCustomValue = (val) => {
+  if (val === null || val === void 0) return "None";
+  if (typeof val === "string" || typeof val === "number") return String(val);
+  return JSON.stringify(val, null, 2);
+};
+var renderRelationSingle = (context) => {
+  const { Text } = getNative2();
+  const { field, fieldKey, label, required, disabled, error, onRelationAction } = context;
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    onRelationAction ? createElement(
+      Button,
+      {
+        disabled,
+        onPress: () => onRelationAction({
+          action: "open",
+          fieldKey,
+          field,
+          value: void 0,
+          fullPaging: field.tags?.fullPaging,
+          onChange: context.onChange
+        })
+      },
+      "Manage"
+    ) : null,
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderRelationArray = (context) => {
+  const { Text } = getNative2();
+  const { field, fieldKey, label, required, disabled, error, onRelationAction } = context;
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    onRelationAction ? createElement(
+      Button,
+      {
+        disabled,
+        onPress: () => onRelationAction({
+          action: "open",
+          fieldKey,
+          field,
+          value: void 0,
+          fullPaging: field.tags?.fullPaging,
+          onChange: context.onChange
+        })
+      },
+      "Manage"
+    ) : null,
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderCustomSingle = (context) => {
+  const { Text } = getNative2();
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const customType = field.tags?.customType;
+  const onCustomTypeAction = context.onCustomTypeAction;
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    createElement(Text, null, formatCustomValue(context.value)),
+    customType && onCustomTypeAction ? createElement(
+      Button,
+      {
+        disabled,
+        onPress: () => onCustomTypeAction({
+          action: "open",
+          fieldKey,
+          field,
+          customType,
+          value: context.value,
+          onChange: context.onChange
+        })
+      },
+      "Manage"
+    ) : null,
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderCustomArray = (context) => {
+  const { Text, View } = getNative2();
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const customType = field.tags?.customType;
+  const onCustomTypeAction = context.onCustomTypeAction;
+  const arrayValue = Array.isArray(context.value) ? context.value : [];
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    createElement(
+      View,
+      { style: { gap: 8, marginBottom: 8 } },
+      arrayValue.length === 0 ? createElement(Text, null, "No items yet.") : arrayValue.map(
+        (item, index) => createElement(
+          View,
+          { key: `${fieldKey}-${index}`, style: { gap: 4 } },
+          createElement(Text, null, formatCustomValue(item)),
+          createElement(
+            View,
+            { style: { flexDirection: "row", gap: 8, flexWrap: "wrap" } },
+            customType && onCustomTypeAction ? createElement(
+              Button,
+              {
+                disabled,
+                onPress: () => onCustomTypeAction({
+                  action: "edit",
+                  fieldKey,
+                  field,
+                  customType,
+                  value: context.value,
+                  index,
+                  onChange: context.onChange
+                })
+              },
+              "Manage"
+            ) : null,
+            customType && onCustomTypeAction ? createElement(
+              Button,
+              {
+                disabled,
+                onPress: () => onCustomTypeAction({
+                  action: "remove",
+                  fieldKey,
+                  field,
+                  customType,
+                  value: context.value,
+                  index,
+                  onChange: context.onChange
+                })
+              },
+              "Remove"
+            ) : null
+          )
+        )
+      )
+    ),
+    customType && onCustomTypeAction ? createElement(
+      Button,
+      {
+        disabled,
+        onPress: () => onCustomTypeAction({
+          action: "add",
+          fieldKey,
+          field,
+          customType,
+          value: context.value,
+          onChange: context.onChange
+        })
+      },
+      "Add Item"
+    ) : null,
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var autoFieldRenderer;
+var renderArray = (context) => {
+  const { Text, View } = getNative2();
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const itemField = createArrayItemField(field);
+  const arrayValue = Array.isArray(context.value) ? [...context.value] : [];
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    createElement(
+      ArrayContainer,
+      null,
+      arrayValue.map(
+        (item, index) => createElement(
+          ArrayItemWrapper,
+          { key: index },
+          createElement(
+            View,
+            { style: { flex: 1 } },
+            autoFieldRenderer({
+              field: itemField,
+              fieldKey: `${fieldKey}[${index}]`,
+              value: item,
+              onChange: (newItem) => {
+                const newValue = [...arrayValue];
+                newValue[index] = newItem;
+                context.onChange(newValue);
+              },
+              disabled
+            })
+          ),
+          createElement(
+            Button,
+            {
+              disabled,
+              onPress: () => {
+                const newValue = [...arrayValue];
+                newValue.splice(index, 1);
+                context.onChange(newValue);
+              }
+            },
+            "Remove"
+          )
+        )
+      ),
+      createElement(
+        Button,
+        {
+          disabled,
+          onPress: () => {
+            const baseValue = Array.isArray(context.value) ? context.value : [];
+            const newValue = [...baseValue];
+            const newItem = field.type === "number" ? 0 : field.type === "boolean" ? false : "";
+            newValue.push(newItem);
+            context.onChange(newValue);
+          }
+        },
+        "Add Item"
+      )
+    ),
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderString = (context) => {
+  const { Text, TextInput } = getNative2();
+  const { label, required, disabled, error } = context;
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    createElement(TextInput, {
+      value: context.value || "",
+      onChangeText: (value) => context.onChange(value),
+      editable: !disabled,
+      placeholder: label
+    }),
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderNumber = (context) => {
+  const { Text, TextInput } = getNative2();
+  const { label, required, disabled, error } = context;
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    createElement(TextInput, {
+      value: context.value !== void 0 ? String(context.value) : "",
+      onChangeText: (value) => context.onChange(parseNumberValue(value)),
+      editable: !disabled,
+      keyboardType: "numeric",
+      placeholder: label
+    }),
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderBoolean = (context) => {
+  const { Text, View, Switch } = getNative2();
+  const { label, disabled, error } = context;
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(
+      View,
+      { style: { flexDirection: "row", alignItems: "center", gap: 8 } },
+      createElement(Switch, {
+        value: !!context.value,
+        onValueChange: (value) => context.onChange(value),
+        disabled
+      }),
+      createElement(Text, null, label)
+    ),
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var renderEnumSelect = (context) => {
+  const { Text, View } = getNative2();
+  const { field, label, required, disabled, error } = context;
+  const selectableValues = getSelectableValues(context.possibleValues) ?? [];
+  return createElement(
+    FieldWrapper,
+    null,
+    createElement(Text, null, `${label} ${required ? "*" : ""}`),
+    createElement(
+      View,
+      { style: { gap: 8 } },
+      selectableValues.map(
+        (val) => createElement(
+          Button,
+          {
+            key: String(val),
+            disabled,
+            onPress: () => context.onChange(
+              field.type === "number" ? Number(val) : String(val)
+            )
+          },
+          String(val)
+        )
+      )
+    ),
+    error ? createElement(ErrorMessage, null, error) : null
+  );
+};
+var nativeSuite = {
+  renderers: {
+    string: renderString,
+    number: renderNumber,
+    boolean: renderBoolean,
+    enum_select: renderEnumSelect,
+    array: renderArray,
+    relation_single: renderRelationSingle,
+    relation_array: renderRelationArray,
+    custom_single: renderCustomSingle,
+    custom_array: renderCustomArray
+  }
+};
+var resolvedNativeSuite = resolveSuite(void 0, nativeSuite);
+autoFieldRenderer = createAutoField(resolvedNativeSuite);
+var nativeAutoField = autoFieldRenderer;
+
+// src/native/forms/createNativeFormRenderer.ts
+var createNativeFormRenderer = (options) => {
+  return createFormRenderer({
+    fallbackSuite: nativeSuite,
+    suite: options?.suite
+  });
+};
+
+// 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;
+  }
+};
+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/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);
+    }
+  };
+};
+
+// 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/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/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/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/native/utils/EasyLayout.tsx
+var roundTo = (value, decimals) => {
+  const places = Number.isFinite(decimals) ? Math.max(0, decimals) : 3;
+  const factor = Math.pow(10, places);
+  return Math.round(value * factor) / factor;
+};
+var sumTrackWindow = (tracks, startIndex, endIndex, gapPx) => {
+  if (endIndex < startIndex) {
+    return 0;
+  }
+  const trackSum = tracks.slice(startIndex, endIndex + 1).reduce((acc, value) => acc + value, 0);
+  const gaps = (endIndex - startIndex) * gapPx;
+  return trackSum + Math.max(0, gaps);
+};
+var sumBeforeTrack = (tracks, startIndex, gapPx) => {
+  if (startIndex <= 0) {
+    return 0;
+  }
+  const trackSum = tracks.slice(0, startIndex).reduce((acc, value) => acc + value, 0);
+  const gaps = startIndex * Math.max(0, gapPx);
+  return trackSum + gaps;
+};
+var computeCoords = (parsed, bounds, { width, height, padding = 0, gap = 0, roundToDecimals = 3 }) => {
+  const rowTracks = parsed.rowTracks.length ? parsed.rowTracks : parsed.areaGrid.map(() => ({ kind: "fr", value: 1 }));
+  const colTracks = parsed.colTracks.length ? parsed.colTracks : parsed.areaGrid[0].map(() => ({ kind: "fr", value: 1 }));
+  const rowPixels = computeTrackPixels({
+    tracks: rowTracks,
+    totalPx: Math.max(0, height),
+    gapPx: gap,
+    paddingPx: padding
+  });
+  const colPixels = computeTrackPixels({
+    tracks: colTracks,
+    totalPx: Math.max(0, width),
+    gapPx: gap,
+    paddingPx: padding
+  });
+  const result = {};
+  for (const areaName of parsed.areaNames) {
+    const area = bounds[areaName];
+    if (!area) {
+      continue;
+    }
+    const left = Math.max(0, padding) + sumBeforeTrack(colPixels, area.colStart - 1, Math.max(0, gap));
+    const top = Math.max(0, padding) + sumBeforeTrack(rowPixels, area.rowStart - 1, Math.max(0, gap));
+    const areaWidth = sumTrackWindow(
+      colPixels,
+      area.colStart - 1,
+      area.colEnd - 1,
+      Math.max(0, gap)
+    );
+    const areaHeight = sumTrackWindow(
+      rowPixels,
+      area.rowStart - 1,
+      area.rowEnd - 1,
+      Math.max(0, gap)
+    );
+    result[areaName] = {
+      left: roundTo(left, roundToDecimals),
+      top: roundTo(top, roundToDecimals),
+      width: roundTo(areaWidth, roundToDecimals),
+      height: roundTo(areaHeight, roundToDecimals)
+    };
+  }
+  return result;
+};
+var makeNativeEasyLayout = (template) => {
+  const parsed = parseTemplate(template);
+  validateAreas(parsed);
+  const bounds = computeAreaBounds(parsed);
+  return {
+    template,
+    parsed,
+    bounds,
+    areaNames: parsed.areaNames,
+    computeNativeCoords: (input) => computeCoords(parsed, bounds, input)
+  };
+};
+var useNativeEasyLayout = (layout, input) => {
+  return useMemo(
+    () => layout.computeNativeCoords(input),
+    [
+      layout,
+      input.width,
+      input.height,
+      input.padding,
+      input.gap,
+      input.roundToDecimals
+    ]
+  );
+};
+var NativeEasyLayoutView = ({
+  layout,
+  areaChildren = {},
+  ViewComponent,
+  containerStyle = {},
+  areaStyle = {},
+  onLayout,
+  ...input
+}) => {
+  const coords = useNativeEasyLayout(layout, input);
+  const Container = ViewComponent || "div";
+  return createElement(
+    Container,
+    {
+      onLayout,
+      style: {
+        position: "relative",
+        width: input.width,
+        height: input.height,
+        ...containerStyle
+      }
+    },
+    layout.areaNames.map(
+      (areaName) => createElement(
+        Container,
+        {
+          key: areaName,
+          style: {
+            position: "absolute",
+            ...coords[areaName],
+            ...areaStyle
+          }
+        },
+        areaChildren[areaName] ?? null
+      )
+    )
+  );
+};
+
+// src/native/utils/History.ts
+var mapNativeURLToPath = (url) => buildHistoryPath(parseHistoryPath(url));
+var createNativeHistory = (options = {}) => {
+  const {
+    adapter,
+    initialPath = "/",
+    onIncomingURL = "replace",
+    mapURLToPath = mapNativeURLToPath
+  } = options;
+  const history = createMemoryHistory(initialPath);
+  let unsubscribe;
+  let started = false;
+  const applyIncomingURL = (url) => {
+    if (!url) {
+      return;
+    }
+    const targetPath = mapURLToPath(url);
+    if (!targetPath) {
+      return;
+    }
+    if (onIncomingURL === "push") {
+      history.push(targetPath, { replaceSearch: true });
+    } else {
+      history.replace(targetPath, { replaceSearch: true });
+    }
+  };
+  return {
+    get location() {
+      return history.location;
+    },
+    get length() {
+      return history.length;
+    },
+    get index() {
+      return history.index;
+    },
+    push: history.push,
+    replace: history.replace,
+    go: history.go,
+    back: history.back,
+    forward: history.forward,
+    listen: history.listen,
+    start: async () => {
+      if (started) {
+        return;
+      }
+      started = true;
+      if (!adapter) {
+        return;
+      }
+      const startKey = history.location.key;
+      const startIndex = history.index;
+      unsubscribe = adapter.subscribe((url) => {
+        const targetPath = mapURLToPath(url);
+        if (!targetPath) {
+          return;
+        }
+        const userNavigated = history.location.key !== startKey || history.index !== startIndex;
+        if (userNavigated && targetPath === initialPath) {
+          return;
+        }
+        if (onIncomingURL === "push") {
+          history.push(targetPath, { replaceSearch: true });
+        } else {
+          history.replace(targetPath, { replaceSearch: true });
+        }
+      });
+      const initialURL = await adapter.getInitialURL();
+      if (history.location.key === startKey && history.index === startIndex) {
+        applyIncomingURL(initialURL);
+      }
+    },
+    stop: () => {
+      if (!started) {
+        return;
+      }
+      unsubscribe?.();
+      unsubscribe = void 0;
+      started = false;
+    }
+  };
+};
+var createNativeBackHandler = (history) => {
+  return {
+    /**
+     * @returns True when back navigation was handled by history.
+     */
+    handle: () => {
+      if (history.index > 0) {
+        history.back();
+        return true;
+      }
+      return false;
+    }
+  };
+};
+
+// 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 });
+    }
+  };
+};
+var NativeRouteProvider = ({
+  children,
+  history,
+  ...historyOptions
+}) => {
+  const historyRef = useRef(history ?? null);
+  if (!historyRef.current) {
+    historyRef.current = createNativeHistory(historyOptions);
+  }
+  const adapterRef = useRef(createRouteAdapterFromHistory(historyRef.current));
+  useEffect(() => {
+    const targetHistory = historyRef.current;
+    if (!targetHistory) {
+      return;
+    }
+    void targetHistory.start();
+    return () => {
+      targetHistory.stop();
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(RouteProvider, { adapter: adapterRef.current, children });
+};
+var NativeRoute = (props) => {
+  const routeContext = useRouteContext();
+  const hasAdapter = useMemo(
+    () => typeof routeContext.adapter !== "undefined",
+    [routeContext.adapter]
+  );
+  if (hasAdapter) {
+    return /* @__PURE__ */ jsx(Route, { ...props });
+  }
+  return /* @__PURE__ */ jsx(NativeRouteProvider, { children: /* @__PURE__ */ jsx(Route, { ...props }) });
+};
+
+// src/native/utils/Route.ts
+var createNavigationStateRouteAdapter = (options) => {
+  const getPath = () => options.toPath(options.getState());
+  return {
+    getPath,
+    subscribe: (listener) => options.subscribe(() => {
+      listener(getPath());
+    }),
+    push: options.navigate ? (path) => options.navigate?.(path) : void 0,
+    replace: options.replace ? (path) => options.replace?.(path) : void 0
+  };
+};
+var expandPattern = (pattern, params = {}) => {
+  const segments = getPathArray(pattern, "/", true, true, false, false);
+  return segments.map((segment) => {
+    if (segment.startsWith(":")) {
+      const key = segment.slice(1);
+      if (!(key in params)) {
+        throw new Error(`Missing param "${key}" for route pattern "${pattern}".`);
+      }
+      return params[key];
+    }
+    return segment;
+  });
+};
+var buildPathFromRouteChain = (routeChain, config, query) => {
+  const segments = [];
+  routeChain.forEach((route) => {
+    const pattern = config[route.name];
+    if (!pattern) {
+      throw new Error(`Missing route pattern for "${route.name}".`);
+    }
+    segments.push(...expandPattern(pattern, route.params));
+  });
+  return buildRoutePath(segments, query);
+};
+
+export { ArrayContainer, ArrayItemWrapper, Button, ErrorMessage, FieldWrapper, NativeEasyLayoutView, NativeRoute, NativeRouteProvider, Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildPathFromRouteChain, buildQueryString, buildRoutePath, createManualRouteAdapter, createMemoryHistory, createNativeBackHandler, createNativeFormRenderer, createNativeHistory, createNavigationStateRouteAdapter, makeNativeEasyLayout, mapNativeURLToPath, nativeAutoField, nativeSuite, parseHistoryPath, useNativeEasyLayout, useRouteContext };