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

package/web/index.js

@@ -0,0 +1,547 @@
+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 { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/app/helpers/styled.ts
+var styled_exports = {};
+__export(styled_exports, {
+  default: () => styled_default
+});
+__reExport(styled_exports, styledBase);
+var styled = typeof styledBase__default.default === "function" ? styledBase__default.default : styledBase__default;
+var styled_default = styled;
+
+// src/web/forms/primitives/index.ts
+var FieldWrapper = styled_default("div")`
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  justify-content: flex-start;
+  gap: 0.25em;
+`;
+var ErrorMessage = styled_default("span")`
+  color: #AA0000;
+`;
+var ArrayContainer = styled_default("div")`
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  justify-content: flex-start;
+  gap: 0.5em;
+`;
+var ArrayItemWrapper = styled_default("div")`
+  display: flex;
+  flex-direction: row;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 0.5em;
+`;
+var createArrayItemField = (field) => ({
+  ...field,
+  array: false,
+  tags: {
+    ...field.tags,
+    label: void 0
+  }
+});
+var toOptionValue = (val) => {
+  if (val === null || val === void 0) return void 0;
+  if (typeof val === "boolean") return void 0;
+  return String(val);
+};
+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 { field, fieldKey, label, required, disabled, error, onRelationAction } = context;
+  const id = `field-${fieldKey}`;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    onRelationAction ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        "data-signifier": "manage",
+        type: "button",
+        disabled,
+        onClick: () => onRelationAction({
+          action: "open",
+          fieldKey,
+          field,
+          value: void 0,
+          fullPaging: field.tags?.fullPaging,
+          onChange: context.onChange
+        }),
+        children: "Manage"
+      }
+    ) : void 0,
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderRelationArray = (context) => {
+  const { field, fieldKey, label, required, disabled, error, onRelationAction } = context;
+  const id = `field-${fieldKey}`;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    onRelationAction ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        "data-signifier": "manage-related",
+        type: "button",
+        disabled,
+        onClick: () => onRelationAction({
+          action: "open",
+          fieldKey,
+          field,
+          value: void 0,
+          fullPaging: field.tags?.fullPaging,
+          onChange: context.onChange
+        }),
+        children: "Manage"
+      }
+    ) : void 0,
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderCustomSingle = (context) => {
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  const customType = field.tags?.customType;
+  const onCustomTypeAction = context.onCustomTypeAction;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    /* @__PURE__ */ jsx(RelationValue, { children: formatCustomValue(context.value) }),
+    customType && onCustomTypeAction ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        "data-signifier": "manage",
+        type: "button",
+        disabled,
+        onClick: () => onCustomTypeAction({
+          action: "open",
+          fieldKey,
+          field,
+          customType,
+          value: context.value,
+          onChange: context.onChange
+        }),
+        children: "Manage"
+      }
+    ) : void 0,
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderCustomArray = (context) => {
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  const customType = field.tags?.customType;
+  const onCustomTypeAction = context.onCustomTypeAction;
+  const arrayValue = Array.isArray(context.value) ? context.value : [];
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    /* @__PURE__ */ jsxs(RelationList, { children: [
+      arrayValue.length === 0 && /* @__PURE__ */ jsx(RelationValue, { children: "No items yet." }),
+      arrayValue.map((item, index) => /* @__PURE__ */ jsxs(RelationItem, { children: [
+        /* @__PURE__ */ jsx(RelationValue, { children: formatCustomValue(item) }),
+        /* @__PURE__ */ jsxs(RelationActions, { children: [
+          customType && onCustomTypeAction ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              "data-signifier": "manage",
+              type: "button",
+              disabled,
+              onClick: () => onCustomTypeAction({
+                action: "edit",
+                fieldKey,
+                field,
+                customType,
+                value: context.value,
+                index,
+                onChange: context.onChange
+              }),
+              children: "Manage"
+            }
+          ) : void 0,
+          customType && onCustomTypeAction ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              disabled,
+              onClick: () => onCustomTypeAction({
+                action: "remove",
+                fieldKey,
+                field,
+                customType,
+                value: context.value,
+                index,
+                onChange: context.onChange
+              }),
+              children: "Remove"
+            }
+          ) : void 0
+        ] })
+      ] }, `${fieldKey}-${index}`))
+    ] }),
+    customType && onCustomTypeAction ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: () => onCustomTypeAction({
+          action: "add",
+          fieldKey,
+          field,
+          customType,
+          value: context.value,
+          onChange: context.onChange
+        }),
+        children: "Add Item"
+      }
+    ) : void 0,
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderArray = (context) => {
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  const itemField = createArrayItemField(field);
+  const arrayValue = Array.isArray(context.value) ? [...context.value] : [];
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    /* @__PURE__ */ jsxs(ArrayContainer, { children: [
+      arrayValue.map((item, index) => /* @__PURE__ */ jsxs(ArrayItemWrapper, { children: [
+        /* @__PURE__ */ jsx("div", { style: { flex: 1 }, children: context.renderField({
+          field: itemField,
+          fieldKey: `${fieldKey}[${index}]`,
+          value: item,
+          onChange: (newItem) => {
+            const newValue = [...arrayValue];
+            newValue[index] = newItem;
+            context.onChange(newValue);
+          },
+          disabled
+        }) }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            disabled,
+            onClick: () => {
+              const newValue = [...arrayValue];
+              newValue.splice(index, 1);
+              context.onChange(newValue);
+            },
+            children: "Remove"
+          }
+        )
+      ] }, index)),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          disabled,
+          onClick: () => {
+            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);
+          },
+          children: "Add Item"
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderString = (context) => {
+  const { fieldKey, label, required, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        id,
+        type: context.format || "text",
+        value: context.value || "",
+        onChange: (e) => context.onChange(e.target.value),
+        disabled,
+        pattern: context.constraints?.pattern
+      }
+    ),
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderNumber = (context) => {
+  const { fieldKey, label, required, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        id,
+        type: "number",
+        value: context.value ?? "",
+        onChange: (e) => context.onChange(parseNumberValue(e.target.value)),
+        disabled,
+        min: context.constraints?.min,
+        max: context.constraints?.max,
+        step: context.constraints?.step
+      }
+    ),
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderBoolean = (context) => {
+  const { fieldKey, label, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("div", { children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          id,
+          type: "checkbox",
+          checked: !!context.value,
+          onChange: (e) => context.onChange(e.target.checked),
+          disabled
+        }
+      ),
+      /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+        " ",
+        label,
+        " "
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var renderEnumSelect = (context) => {
+  const { field, fieldKey, label, required, disabled, error } = context;
+  const id = `field-${fieldKey}`;
+  const selectableValues = getSelectableValues(context.possibleValues);
+  const allowCustom = context.allowCustomSelection;
+  return /* @__PURE__ */ jsxs(FieldWrapper, { children: [
+    /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      " ",
+      required && "*"
+    ] }),
+    (field.type === "string" || field.type === "number") && selectableValues && allowCustom && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          id,
+          type: "text",
+          list: `list-${id}`,
+          value: context.value ?? "",
+          onChange: (e) => context.onChange(
+            field.type === "number" ? parseNumberValue(e.target.value) : e.target.value
+          ),
+          placeholder: "Select or type...",
+          disabled
+        }
+      ),
+      /* @__PURE__ */ jsx("datalist", { id: `list-${id}`, children: selectableValues.map((val) => /* @__PURE__ */ jsx("option", { value: toOptionValue(val) }, String(val))) })
+    ] }),
+    (field.type === "string" || field.type === "number") && selectableValues && !allowCustom && /* @__PURE__ */ jsxs(
+      "select",
+      {
+        id,
+        value: context.value ?? "",
+        onChange: (e) => context.onChange(
+          field.type === "number" ? parseNumberValue(e.target.value) : e.target.value
+        ),
+        disabled,
+        children: [
+          /* @__PURE__ */ jsx("option", { value: "", children: "Select..." }),
+          selectableValues.map((val) => /* @__PURE__ */ jsx("option", { value: toOptionValue(val), children: String(val) }, String(val)))
+        ]
+      }
+    ),
+    error && /* @__PURE__ */ jsx(ErrorMessage, { children: error })
+  ] });
+};
+var FormRoot = ({
+  children,
+  onSubmit
+}) => {
+  const handleSubmit = (event) => {
+    event.preventDefault();
+    onSubmit?.();
+  };
+  return /* @__PURE__ */ jsx("form", { onSubmit: handleSubmit, children });
+};
+var SuiteButton = ({
+  children,
+  disabled,
+  type,
+  onClick,
+  "data-signifier": dataSignifier
+}) => {
+  return createElement(
+    "button",
+    {
+      type: type ?? "button",
+      disabled,
+      onClick: type === "submit" ? void 0 : onClick,
+      "data-signifier": dataSignifier
+    },
+    children
+  );
+};
+var webSuite = {
+  renderers: {
+    string: renderString,
+    number: renderNumber,
+    boolean: renderBoolean,
+    enum_select: renderEnumSelect,
+    array: renderArray,
+    relation_single: renderRelationSingle,
+    relation_array: renderRelationArray,
+    custom_single: renderCustomSingle,
+    custom_array: renderCustomArray
+  },
+  primitives: {
+    FormRoot,
+    FieldWrapper,
+    ErrorMessage,
+    Label: ({ children, htmlFor }) => createElement("label", { htmlFor }, children),
+    Button: SuiteButton
+  }
+};
+var webAutoField = createFormRenderer({
+  fallbackSuite: webSuite
+}).AutoField;
+var RelationList = styled_default("div")`
+  display: flex;
+  flex-direction: column;
+  gap: 0.5em;
+  margin-bottom: 0.5em;
+`;
+var RelationItem = styled_default("div")`
+  display: flex;
+  flex-direction: column;
+  gap: 0.5em;
+  padding: 0.5em;
+`;
+var RelationValue = styled_default("pre")`
+  margin: 0;
+  padding: 0.5em;
+  font-size: 0.85em;
+  white-space: pre-wrap;
+`;
+var RelationActions = styled_default("div")`
+  display: flex;
+  gap: 0.5em;
+  flex-wrap: wrap;
+`;
+
+// src/web/forms/createWebFormRenderer.ts
+var createWebFormRenderer = (options) => {
+  return createFormRenderer({
+    fallbackSuite: webSuite,
+    suite: options?.suite
+  });
+};
+var defaultWebRenderer = createWebFormRenderer();
+var AutoField = (props) => {
+  return webAutoField({
+    field: props.field,
+    fieldKey: props.fieldKey,
+    value: props.value,
+    onChange: props.onChange,
+    error: props.error,
+    disabled: props.disabled,
+    onRelationAction: props.onRelationAction,
+    onCustomTypeAction: props.onCustomTypeAction
+  });
+};
+var AutoFormView2 = (props) => {
+  return /* @__PURE__ */ jsx(AutoFormView, { ...props, renderer: defaultWebRenderer });
+};
+var AutoForm2 = (props) => {
+  return /* @__PURE__ */ jsx(AutoForm, { ...props, renderer: defaultWebRenderer });
+};
+var EasyLayoutBase = styled_default("div")`
+  display: grid;
+  ${({ $layoutCss }) => $layoutCss}
+`;
+var EasyAreaBase = styled_default("div")`
+  grid-area: ${({ $area }) => $area};
+`;
+var styledFactory = {
+  createLayout: ({ base, css }) => {
+    const LayoutComponent = ({ children }) => {
+      const layoutProps = {
+        $layoutCss: css,
+        children
+      };
+      if (base) {
+        layoutProps.as = base;
+      }
+      return /* @__PURE__ */ jsx(EasyLayoutBase, { ...layoutProps });
+    };
+    return LayoutComponent;
+  },
+  createArea: ({ base, area }) => {
+    const AreaComponent = ({ children }) => {
+      const areaProps = {
+        $area: area,
+        children
+      };
+      if (base) {
+        areaProps.as = base;
+      }
+      return /* @__PURE__ */ jsx(EasyAreaBase, { ...areaProps });
+    };
+    return AreaComponent;
+  }
+};
+var getEasyLayout = (extendFrom, areasExtendFrom, options = {}) => {
+  return createEasyLayout(styledFactory, extendFrom, areasExtendFrom, options);
+};
+
+export { ArrayContainer, ArrayItemWrapper, AutoField, AutoForm2 as AutoForm, AutoFormView2 as AutoFormView, ErrorMessage, FieldWrapper, createWebFormRenderer, getEasyLayout, webAutoField, webSuite };

package/web/utils/EasyLayout.d.ts

@@ -0,0 +1,47 @@
+import { type EasyLayoutSpacing, type FCWithChildren, type LayoutComponents } from "../../app/utils/EasyLayout";
+/**
+ * Quickly express advanced, extensible grid layouts with styled-components.
+ * Template syntax:
+ * - Row lines: `<area area ...>, <track>`
+ * - Optional column line: `\\ <track> <track> ...`
+ *
+ * Supported track units are `fr`, `px`, and `%`.
+ * Parsing and area-shape validation are shared from the app EasyLayout core.
+ * On web, final pixel distribution is resolved by the browser CSS Grid engine.
+ * Optional spacing (`gap`, `padding`) can be provided in `options`.
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   layout: Container,
+ *   areas: {
+ *     Header,
+ *     Side,
+ *     Main,
+ *     Footer,
+ *   },
+ * } = getEasyLayout(styled.div)`
+ *   header header header, 1fr
+ *   side main main, 5fr
+ *   footer footer footer, 1fr
+ *   \\ 1fr 1fr 1fr
+ * `;
+ *
+ * const App = () => {
+ *   return (
+ *     <Container>
+ *       <Header>Header Content</Header>
+ *       <Side>Side Content</Side>
+ *       <Main>Main Content</Main>
+ *       <Footer>Footer Content</Footer>
+ *     </Container>
+ *   );
+ * };
+ * ```
+ *
+ * @param extendFrom - Base component to extend for the layout container.
+ * @param areasExtendFrom - Base component to extend for each area component.
+ * @param options - Optional layout spacing (`gap`, `padding`).
+ * @returns Tagged template function that builds layout components.
+ * */
+export declare const getEasyLayout: (extendFrom?: FCWithChildren, areasExtendFrom?: FCWithChildren, options?: EasyLayoutSpacing) => ((layoutTemplate: TemplateStringsArray, ...expressions: any[]) => LayoutComponents);

package/web/utils/Route.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ *
+ * Web routing exports unified app Route implementation.
+ */
+import { PropsWithChildren } from "react";
+import { Route, useRouteContext } from "../../app/utils/Route";
+import { createBrowserRouteAdapter } from "../../app/utils/UniversalRouteAdapter";
+/**
+ * Backward-compatible web RouteProvider that auto-creates a browser adapter.
+ */
+export declare const RouteProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export { Route, useRouteContext, createBrowserRouteAdapter };
+export type { RouteAdapter, RouteContextType, RouteProps, RouteProviderProps, RouteQuery, RouteQueryValue, } from "../../app/utils/Route";

package/web/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ *
+ * Web-only utilities.
+ */
+export * from "./EasyLayout";

package/src/api/DataAccessControl.d.ts

@@ -1,85 +0,0 @@
-import { LiteralValue } from "../common/TypeParsing/TypeInfo";
-/**
- * The possible types of a data access control (DAC) constraint.
- * */
-export declare enum DACConstraintType {
-    ALLOW = "ALLOW",
-    DENY = "DENY"
-}
-/**
- * A data access control (DAC) constraint.
- * */
-export type DACConstraint = {
-    type: DACConstraintType;
-    resourcePath: LiteralValue[];
-    pathIsPrefix?: boolean;
-};
-/**
- * The primary properties for a data access control (DAC) role.
- * */
-export type BaseDACRole = {
-    childRoleIds?: string[];
-    constraints: DACConstraint[];
-};
-/**
- * A data access control (DAC) role which has been stored and can be accessed by an `id`.
- * */
-export type DACRole = {
-    id: string;
-} & BaseDACRole;
-/**
- * The result of a data access control (DAC) check.
- * */
-export type DACAccessResult = {
-    allowed: boolean;
-    denied: boolean;
-};
-/**
- * The result of a data access control (DAC) check for a data item.
- * */
-export type DACDataItemResourceAccessResultMap = DACAccessResult & {
-    fieldsResources?: Record<string, DACAccessResult>;
-};
-/**
- * The result of matching a DAC path to a resource path.
- * */
-export type DACPathMatchResults = {
-    prefixMatch: boolean;
-    exactMatch: boolean;
-};
-/**
- * The prototype of a DAC wildcard signifier.
- * */
-export declare const WILDCARD_SIGNIFIER_PROTOTYPE: Record<string, string>;
-/**
- * Check if a given DAC path part value is a DAC wildcard signifier.
- * */
-export declare const getValueIsWildcardSignifier: (value: any) => boolean;
-/**
- * Check if a given DAC path matches a given resource path.
- *
- * Includes checking if the DAC path is a prefix of the
- * resource path and if the DAC path is an exact match of
- * the resource path.
- *
- * The DAC path can include wildcard signifier objects at
- * various indices in order to facilitate dynamic matches
- * and grouping by common resource aspects.
- * */
-export declare const getDACPathsMatch: (dacPath: LiteralValue[], resourcePath: LiteralValue[]) => DACPathMatchResults;
-/**
- * Get the flattened constraints of a DAC role.
- * */
-export declare const getFlattenedDACConstraints: (role: DACRole, getDACRoleById: (id: string) => DACRole, 
-/**
- * SECURITY: Don't use this if you want realtime role resolution.
- * */
-dacRoleCache?: Record<string, DACRole>) => DACConstraint[];
-/**
- * Get the access to a given resource for a given DAC role.
- * */
-export declare const getResourceAccessByDACRole: (fullResourcePath: LiteralValue[], role: DACRole, getDACRoleById: (id: string) => DACRole, dacRoleCache?: Record<string, DACRole>) => DACAccessResult;
-/**
- * Merge multiple DAC access results.
- * */
-export declare const mergeDACAccessResults: (...results: DACAccessResult[]) => DACAccessResult;