@resistdesign/voltra 3.0.0-alpha.27 → 3.0.0-alpha.29

package/native/testing/react-native.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+type Listener = () => boolean;
+export declare const Platform: {
+    OS: string;
+};
+export declare const BackHandler: {
+    addEventListener: (_eventName: "hardwareBackPress", listener: Listener) => {
+        remove: () => void;
+    };
+    removeEventListener: (_eventName: "hardwareBackPress", listener: Listener) => void;
+    __triggerHardwareBackPress: () => boolean;
+};
+export declare const View: ({ children, ...props }: Record<string, any>) => React.DOMElement<{
+    [x: string]: any;
+}, Element>;
+export declare const Text: ({ children, ...props }: Record<string, any>) => React.DOMElement<{
+    [x: string]: any;
+}, Element>;
+export declare const Pressable: ({ children, ...props }: Record<string, any>) => React.DOMElement<{
+    [x: string]: any;
+}, Element>;
+export declare const Switch: ({ children, ...props }: Record<string, any>) => React.DOMElement<{
+    [x: string]: any;
+}, Element>;
+export declare const TextInput: ({ children, ...props }: Record<string, any>) => React.DOMElement<{
+    [x: string]: any;
+}, Element>;
+export {};

package/native/utils/Route.d.ts

@@ -3,7 +3,9 @@
  *
  * Native routing helpers that adapt common navigation state to RouteAdapter.
  */
-import type { RouteAdapter, RouteQuery } from "../../app/utils/Route";
+import { type PropsWithChildren } from "react";
+import type { RouteAdapter, RouteContextType, RouteProps, RouteProviderProps, RouteQuery, RouteQueryValue, RouteRuntimeIntegration } from "../../app/utils/Route";
+import { useRouteContext } from "../../app/utils/Route";
 /**
  * Options to adapt a navigation state container into a RouteAdapter.
  */
@@ -19,6 +21,15 @@ export type NavigationStateAdapterOptions<TState> = {
     /** Optional navigation handler used for replace-style transitions. */
     replace?: (path: string) => void;
 };
+/**
+ * Contract for React Native BackHandler-like integrations.
+ */
+export type NativeBackHandlerLike = {
+    addEventListener: (eventName: "hardwareBackPress", listener: () => boolean) => {
+        remove?: () => void;
+    } | void;
+    removeEventListener?: (eventName: "hardwareBackPress", listener: () => boolean) => void;
+};
 /**
  * Route node in a navigation chain.
  */
@@ -39,6 +50,26 @@ export type NavigationRouteConfig = Record<string, string>;
  * @returns RouteAdapter bound to the navigation state.
  */
 export declare const createNavigationStateRouteAdapter: <TState>(options: NavigationStateAdapterOptions<TState>) => RouteAdapter;
+/**
+ * Create a hardware-back listener from a route adapter.
+ */
+export declare const createNativeHardwareBackHandler: (adapter: RouteAdapter) => () => boolean;
+/**
+ * Register hardware-back handling against a BackHandler-like runtime.
+ */
+export declare const registerNativeHardwareBackHandler: (adapter: RouteAdapter, backHandler: NativeBackHandlerLike) => () => void;
+/**
+ * Build a core Route runtime integration using a native BackHandler.
+ */
+export declare const createNativeRouteBackIntegration: (backHandler: NativeBackHandlerLike) => RouteRuntimeIntegration;
+/**
+ * Native Route wrapper for root/provider mode.
+ *
+ * Behavior:
+ * - On mobile native runtimes, injects back-handler integration into app Route.
+ * - On web runtimes, passes no integration so app Route uses browser behavior.
+ */
+export declare const Route: <ParamsType extends Record<string, any>>(props: PropsWithChildren<RouteProps<ParamsType>>) => import("react/jsx-runtime").JSX.Element;
 /**
  * Build a path from a navigation route chain and route config mapping.
  *
@@ -48,3 +79,5 @@ export declare const createNavigationStateRouteAdapter: <TState>(options: Naviga
  * @returns Serialized path string.
  */
 export declare const buildPathFromRouteChain: (routeChain: NavigationRouteNode[], config: NavigationRouteConfig, query?: RouteQuery) => string;
+export { useRouteContext };
+export type { RouteAdapter, RouteContextType, RouteProps, RouteProviderProps, RouteQuery, RouteQueryValue, RouteRuntimeIntegration, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resistdesign/voltra",
-  "version": "3.0.0-alpha.27",
+  "version": "3.0.0-alpha.29",
   "description": "With our powers combined!",
   "homepage": "https://voltra.app",
   "repository": "git@github.com:resistdesign/voltra.git",
@@ -72,19 +72,6 @@
       ]
     }
   },
-  "files": [
-    "*.d.ts",
-    "*.d.ts.map",
-    "api/**",
-    "app/**",
-    "web/**",
-    "native/**",
-    "build/**",
-    "common/**",
-    "iac/**",
-    "README.md",
-    "package.json"
-  ],
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.490.0",
     "@aws-sdk/client-s3": "^3.490.0",

package/web/index.js

@@ -1,132 +1,11 @@
-import { createElement, useEffect, useState, useCallback, useMemo } from 'react';
+import { createEasyLayout } from '../chunk-FQMZMCXU.js';
+import { createFormRenderer, AutoFormView, AutoForm } from '../chunk-WELZGQDJ.js';
+import '../chunk-IWRHGGGH.js';
+import { __export, __reExport } from '../chunk-I2KLQ2HA.js';
+import { createElement } from 'react';
 import * as styledBase from 'styled-components';
 import styledBase__default from 'styled-components';
-import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
-
-// 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/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/createAutoField.ts
-var createAutoField = (suite) => {
-  const renderField = (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,
-      renderField
-    };
-    const kind = getFieldKind(field);
-    return suite.renderers[kind](context);
-  };
-  return renderField;
-};
-
-// src/app/forms/core/createFormRenderer.ts
-var createFormRenderer = (options) => {
-  const resolvedSuite = resolveSuite(
-    options.suite,
-    options.fallbackSuite
-  );
-  const AutoField2 = createAutoField(resolvedSuite);
-  return {
-    AutoField: AutoField2,
-    suite: resolvedSuite
-  };
-};
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 // src/app/helpers/styled.ts
 var styled_exports = {};
@@ -599,209 +478,6 @@ var RelationActions = styled_default("div")`
   gap: 0.5em;
   flex-wrap: wrap;
 `;
-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
-  };
-};
-var fallbackFormRoot = ({
-  children,
-  onSubmit
-}) => {
-  const handleSubmit = (event) => {
-    event.preventDefault();
-    onSubmit?.();
-  };
-  return /* @__PURE__ */ jsx("form", { onSubmit: handleSubmit, children });
-};
-var fallbackButton = ({
-  children,
-  disabled,
-  type,
-  onClick
-}) => {
-  return /* @__PURE__ */ jsx("button", { type: type ?? "button", disabled, onClick, children });
-};
-var AutoFormView = ({
-  controller,
-  onSubmit,
-  renderer,
-  submitDisabled,
-  onRelationAction,
-  onCustomTypeAction
-}) => {
-  const FormRoot2 = renderer.suite.primitives?.FormRoot ?? fallbackFormRoot;
-  const Button = renderer.suite.primitives?.Button ?? fallbackButton;
-  const AutoField2 = renderer.AutoField;
-  const submit = () => {
-    if (controller.validate()) {
-      onSubmit(controller.values);
-    }
-  };
-  return /* @__PURE__ */ jsx(FormRoot2, { onSubmit: submit, children: /* @__PURE__ */ jsxs(Fragment, { children: [
-    controller.fields.filter((fieldController) => !fieldController.hidden).map((fieldController) => /* @__PURE__ */ jsx(
-      AutoField2,
-      {
-        field: fieldController.field,
-        fieldKey: fieldController.key,
-        value: fieldController.value,
-        onChange: fieldController.onChange,
-        error: fieldController.error,
-        onRelationAction,
-        disabled: fieldController.disabled,
-        onCustomTypeAction
-      },
-      fieldController.key
-    )),
-    /* @__PURE__ */ jsx(Button, { type: "submit", onClick: submit, disabled: submitDisabled, children: /* @__PURE__ */ jsx(Fragment, { children: "Submit" }) })
-  ] }) });
-};
-var AutoForm = ({
-  typeInfo,
-  onSubmit,
-  renderer,
-  initialValues,
-  onValuesChange,
-  onRelationAction,
-  onCustomTypeAction,
-  operation,
-  submitDisabled
-}) => {
-  const controller = useFormEngine(initialValues, typeInfo, { operation });
-  useEffect(() => {
-    if (onValuesChange) {
-      onValuesChange(controller.values);
-    }
-  }, [controller.values, onValuesChange]);
-  return /* @__PURE__ */ jsx(
-    AutoFormView,
-    {
-      controller,
-      onSubmit,
-      renderer,
-      onRelationAction,
-      onCustomTypeAction,
-      submitDisabled
-    }
-  );
-};
 
 // src/web/forms/createWebFormRenderer.ts
 var createWebFormRenderer = (options) => {
@@ -829,215 +505,6 @@ var AutoFormView2 = (props) => {
 var AutoForm2 = (props) => {
   return /* @__PURE__ */ jsx(AutoForm, { ...props, renderer: defaultWebRenderer });
 };
-
-// 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 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
-    };
-  };
-};
 var EasyLayoutBase = styled_default("div")`
   display: grid;
   ${({ $layoutCss }) => $layoutCss}

package/iac/types/CloudFormationResourceSpecification.d.ts

@@ -1,2 +0,0 @@
-import { CloudFormationResourceSpecification } from "./Types";
-export declare const CloudFormationResourceSpecificationData: CloudFormationResourceSpecification;