@astroapps/forms-core 1.2.3 → 2.0.1

package/lib/overrideProxy.d.ts

@@ -0,0 +1,7 @@
+import { Control } from "@astroapps/controls";
+export declare function createOverrideProxy<A extends object, B extends Record<string, any>>(proxyFor: A, handlers: Control<B>): A;
+declare class NoValue {
+}
+export declare const NoOverride: NoValue;
+export type KeysOfUnion<T> = T extends T ? keyof T : never;
+export {};

package/lib/resolveChildren.d.ts

@@ -0,0 +1,19 @@
+import { ChangeListenerFunc, CleanupScope, Control } from "@astroapps/controls";
+import { ControlDefinition } from "./controlDefinition";
+import { SchemaDataNode } from "./schemaDataNode";
+import { FormNode } from "./formNode";
+import { FormStateNode } from "./formStateNode";
+export type ChildResolverFunc = (c: FormStateNode) => ChildNodeSpec[];
+export interface ChildNodeSpec {
+    childKey: string | number;
+    create: (scope: CleanupScope, meta: Record<string, any>) => ChildNodeInit;
+}
+export interface ChildNodeInit {
+    definition?: ControlDefinition;
+    parent?: SchemaDataNode;
+    node?: FormNode | null;
+    variables?: (changes: ChangeListenerFunc<any>) => Record<string, any>;
+    resolveChildren?: ChildResolverFunc;
+}
+export declare function defaultResolveChildNodes(formStateNode: FormStateNode): ChildNodeSpec[];
+export declare function resolveArrayChildren(data: SchemaDataNode, node: FormNode, adjustChild?: (elem: Control<any>, index: number) => Partial<ChildNodeInit>): ChildNodeSpec[];

package/lib/schemaDataNode.d.ts

@@ -34,3 +34,6 @@ export declare function schemaDataForFieldRef(fieldRef: string | undefined, sche
 export declare function schemaDataForFieldPath(fieldPath: string[], dataNode: SchemaDataNode): SchemaDataNode;
 export declare function validDataNode(context: SchemaDataNode): boolean;
 export declare function hideDisplayOnly(context: SchemaDataNode, schemaInterface: SchemaInterface, definition: ControlDefinition): boolean | undefined;
+export declare function getLoadingControl(data: Control<any>): Control<boolean>;
+export declare function getRefreshingControl(data: Control<any>): Control<boolean>;
+export declare function getHasMoreControl(data: Control<any>): Control<boolean>;

package/lib/schemaNode.d.ts

@@ -15,7 +15,8 @@ export declare class SchemaNode {
     field: SchemaField;
     tree: SchemaTree;
     parent?: SchemaNode | undefined;
-    constructor(id: string, field: SchemaField, tree: SchemaTree, parent?: SchemaNode | undefined);
+    private getChildFields?;
+    constructor(id: string, field: SchemaField, tree: SchemaTree, parent?: SchemaNode | undefined, getChildFields?: (() => SchemaField[]) | undefined);
     getSchema(schemaId: string): SchemaNode | undefined;
     getUnresolvedFields(): SchemaField[];
     getResolvedParent(noRecurse?: boolean): SchemaNode | undefined;
@@ -37,6 +38,8 @@ export declare function traverseData(fieldPath: string[], root: SchemaNode, data
     [k: string]: any;
 }): unknown;
 export declare function schemaForFieldPath(fieldPath: string[], schema: SchemaNode): SchemaNode;
+export declare function schemaForDataPath(fieldPath: string[], schema: SchemaNode): DataPathNode;
+export declare function getParentDataPath({ node, element, }: DataPathNode): DataPathNode | undefined;
 export declare function getSchemaNodePath(node: SchemaNode): string[];
 export declare function getSchemaNodePathString(node: SchemaNode): string;
 export declare function isCompoundNode(node: SchemaNode): boolean;
@@ -52,3 +55,7 @@ export declare function relativePath(parent: SchemaNode, child: SchemaNode): str
  * @param childPath
  */
 export declare function relativeSegmentPath(parentPath: string[], childPath: string[]): string;
+export interface DataPathNode {
+    node: SchemaNode;
+    element: boolean;
+}

package/lib/schemaValidator.d.ts

@@ -25,3 +25,6 @@ export interface DateValidator extends SchemaValidator {
     fixedDate?: string | null;
     daysFromCurrent?: number | null;
 }
+export declare function jsonataValidator(expr: string): JsonataValidator;
+export declare function dateValidator(comparison: DateComparison, fixedDate?: string | null, daysFromCurrent?: number | null): DateValidator;
+export declare function lengthValidator(min?: number | null, max?: number | null): LengthValidator;

package/lib/validators.d.ts

@@ -1,10 +1,9 @@
 import { DateValidator, JsonataValidator, LengthValidator, SchemaValidator } from "./schemaValidator";
 import { ControlDefinition } from "./controlDefinition";
 import { SchemaDataNode } from "./schemaDataNode";
-import { Control } from "@astroapps/controls";
+import { CleanupScope, Control } from "@astroapps/controls";
 import { SchemaInterface } from "./schemaInterface";
-import { FormContextOptions } from "./formState";
-import { FormNode } from "./formNode";
+import { VariablesFunc } from "./formStateNode";
 export interface ValidationEvalContext {
     addSync(validate: (value: unknown) => string | undefined | null): void;
     addCleanup(cleanup: () => void): void;
@@ -12,7 +11,7 @@ export interface ValidationEvalContext {
     parentData: SchemaDataNode;
     data: SchemaDataNode;
     schemaInterface: SchemaInterface;
-    formContext: Control<FormContextOptions>;
+    variables?: VariablesFunc;
     runAsync(af: () => void): void;
 }
 export type ValidatorEval<T extends SchemaValidator> = (validation: T, context: ValidationEvalContext) => void;
@@ -21,4 +20,4 @@ export declare const lengthValidator: ValidatorEval<LengthValidator>;
 export declare const dateValidator: ValidatorEval<DateValidator>;
 export declare const defaultValidators: Record<string, ValidatorEval<any>>;
 export declare function createValidators(def: ControlDefinition, context: ValidationEvalContext): void;
-export declare function setupValidation(controlImpl: Control<FormContextOptions>, definition: ControlDefinition, dataNode: Control<SchemaDataNode | undefined>, schemaInterface: SchemaInterface, parent: SchemaDataNode, formNode: FormNode, hidden: Control<boolean>, runAsync: (af: () => void) => void): void;
+export declare function setupValidation(scope: CleanupScope, variables: VariablesFunc | undefined, definition: ControlDefinition, dataNode: Control<SchemaDataNode | undefined>, schemaInterface: SchemaInterface, parent: SchemaDataNode, visible: Control<boolean | null>, runAsync: (af: () => void) => void): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astroapps/forms-core",
-  "version": "1.2.3",
+  "version": "2.0.1",
   "description": "",
   "type": "module",
   "main": "lib/index.cjs",
@@ -31,13 +31,13 @@
     "jsonata": "^2.0.4"
   },
   "peerDependencies": {
-    "@astroapps/controls": "^1.3.0"
+    "@astroapps/controls": "^1.4.0"
   },
   "devDependencies": {
-    "@astroapps/controls": "^1.3.0",
+    "@astroapps/controls": "^1.4.0",
     "jest": "^29.7.0",
     "tsx": "^4.19.1",
-    "fast-check": "^3.22.0",
+    "fast-check": "^3.23.2",
     "ts-jest": "^29.2.5",
     "@jest/globals": "^29.7.0",
     "typedoc": "^0.27.2",
@@ -52,7 +52,7 @@
   },
   "scripts": {
     "build": "rimraf ./lib/ node_modules/.cache && microbundle -f modern,cjs --no-compress",
-    "watch": "microbundle -w -f modern,cjs --no-compress",
+    "watch": "microbundle -f modern,cjs --no-compress",
     "test": "jest --coverage",
     "play": "tsx test/play.ts",
     "update-readme": "md-magic --path README.md"

package/src/controlBuilder.ts

@@ -0,0 +1,218 @@
+import {
+  AccordionAdornment,
+  ActionControlDefinition,
+  AutocompleteRenderOptions,
+  CheckListRenderOptions,
+  ControlAdornmentType,
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  DataRenderType,
+  DisplayControlDefinition,
+  DisplayDataType,
+  DisplayOnlyRenderOptions,
+  DynamicProperty,
+  DynamicPropertyType,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  HtmlDisplay,
+  JsonataRenderOptions,
+  RadioButtonRenderOptions,
+  RenderOptions,
+  TextDisplay,
+  TextfieldRenderOptions,
+} from "./controlDefinition";
+import {
+  DateValidator,
+  JsonataValidator,
+  LengthValidator,
+  ValidatorType,
+} from "./schemaValidator";
+import {
+  DataExpression,
+  DataMatchExpression,
+  EntityExpression,
+  ExpressionType,
+  JsonataExpression,
+  NotEmptyExpression,
+} from "./entityExpression";
+
+export function dataControl(
+  field: string,
+  title?: string | null,
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return { type: ControlDefinitionType.Data, field, title, ...options };
+}
+
+export function validatorOptions<A extends { type: string }>(
+  type: ValidatorType,
+): (options: Omit<A, "type">) => A {
+  return (o) => ({ type, ...o }) as A;
+}
+
+export function adornmentOptions<A extends { type: string }>(
+  type: ControlAdornmentType,
+): (options: Omit<A, "type">) => A {
+  return (o) => ({ type, ...o }) as A;
+}
+
+export function renderOptionsFor<A extends RenderOptions>(
+  type: DataRenderType,
+): (options: Omit<A, "type">) => { renderOptions: A } {
+  return (o) => ({ renderOptions: { type, ...o } as A });
+}
+
+export const autocompleteOptions = renderOptionsFor<AutocompleteRenderOptions>(
+  DataRenderType.Autocomplete,
+);
+
+export const checkListOptions = renderOptionsFor<CheckListRenderOptions>(
+  DataRenderType.CheckList,
+);
+
+export const radioButtonOptions = renderOptionsFor<RadioButtonRenderOptions>(
+  DataRenderType.Radio,
+);
+
+export const lengthValidatorOptions = validatorOptions<LengthValidator>(
+  ValidatorType.Length,
+);
+
+export const jsonataValidatorOptions = validatorOptions<JsonataValidator>(
+  ValidatorType.Jsonata,
+);
+
+export const dateValidatorOptions = validatorOptions<DateValidator>(
+  ValidatorType.Date,
+);
+
+export const accordionOptions = adornmentOptions<AccordionAdornment>(
+  ControlAdornmentType.Accordion,
+);
+
+export const textfieldOptions = renderOptionsFor<TextfieldRenderOptions>(
+  DataRenderType.Textfield,
+);
+
+export const displayOnlyOptions = renderOptionsFor<DisplayOnlyRenderOptions>(
+  DataRenderType.DisplayOnly,
+);
+
+export const jsonataOptions = renderOptionsFor<JsonataRenderOptions>(
+  DataRenderType.Jsonata,
+);
+
+export function textDisplayControl(
+  text: string,
+  options?: Partial<DisplayControlDefinition>,
+): DisplayControlDefinition {
+  return {
+    type: ControlDefinitionType.Display,
+    displayData: { type: DisplayDataType.Text, text } as TextDisplay,
+    ...options,
+  };
+}
+
+export function htmlDisplayControl(
+  html: string,
+  options?: Partial<DisplayControlDefinition>,
+): DisplayControlDefinition {
+  return {
+    type: ControlDefinitionType.Display,
+    displayData: { type: DisplayDataType.Html, html } as HtmlDisplay,
+    ...options,
+  };
+}
+
+export function dynamicDefaultValue(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.DefaultValue, expr };
+}
+
+export function dynamicReadonly(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Readonly, expr };
+}
+
+export function dynamicVisibility(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Visible, expr };
+}
+
+export function dynamicDisabled(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Disabled, expr };
+}
+
+export function dataExpr(field: string): DataExpression {
+  return { type: ExpressionType.Data, field };
+}
+
+/**
+ * @deprecated Use dataExpr
+ */
+export const fieldExpr = dataExpr;
+
+/**
+ * @deprecated Use dataMatchExpr
+ */
+export const fieldEqExpr = dataMatchExpr;
+
+export const uuidExpr = { type: ExpressionType.UUID };
+export function dataMatchExpr(field: string, value: any): DataMatchExpression {
+  return { type: ExpressionType.DataMatch, field, value };
+}
+
+export function notEmptyExpr(
+  field: string,
+  empty?: boolean,
+): NotEmptyExpression {
+  return { type: ExpressionType.NotEmpty, field, empty };
+}
+export function jsonataExpr(expression: string): JsonataExpression {
+  return { type: ExpressionType.Jsonata, expression };
+}
+
+export function groupedControl(
+  children: ControlDefinition[],
+  title?: string,
+  options?: Partial<GroupedControlsDefinition>,
+): GroupedControlsDefinition {
+  return {
+    type: ControlDefinitionType.Group,
+    children,
+    title,
+    groupOptions: { type: "Standard", hideTitle: !title },
+    ...options,
+  };
+}
+export function compoundControl(
+  field: string,
+  title: string | undefined | null,
+  children: ControlDefinition[],
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return {
+    type: ControlDefinitionType.Data,
+    field,
+    children,
+    title,
+    renderOptions: { type: "Standard" },
+    ...options,
+  };
+}
+
+export function actionControl(
+  actionText: string,
+  actionId: string,
+  options?: Partial<ActionControlDefinition>,
+): ActionControlDefinition {
+  return {
+    type: ControlDefinitionType.Action,
+    title: actionText,
+    actionId,
+    ...options,
+  };
+}
+export const emptyGroupDefinition: GroupedControlsDefinition = {
+  type: ControlDefinitionType.Group,
+  children: [],
+  groupOptions: { type: GroupRenderType.Standard, hideTitle: true },
+};

package/src/controlDefinition.ts

@@ -22,6 +22,8 @@ export interface ControlDefinition {
   childRefId?: string | null;
   title?: string | null;
   hidden?: boolean | null;
+  disabled?: boolean | null;
+  readonly?: boolean | null;
   styleClass?: string | null;
   textClass?: string | null;
   layoutClass?: string | null;
@@ -56,6 +58,7 @@ export enum DynamicPropertyType {
   AllowedOptions = "AllowedOptions",
   Label = "Label",
   ActionData = "ActionData",
+  GridColumns = "GridColumns",
 }
 
 export interface ControlAdornment {
@@ -133,11 +136,10 @@ export interface DataControlDefinition extends ControlDefinition {
   required?: boolean | null;
   renderOptions?: RenderOptions | null;
   defaultValue?: any;
-  readonly?: boolean | null;
-  disabled?: boolean | null;
   validators?: SchemaValidator[] | null;
   hideTitle?: boolean | null;
   dontClearHidden?: boolean | null;
+  requiredErrorText?: string | null;
 }
 
 export interface RenderOptions {
@@ -165,6 +167,7 @@ export enum DataRenderType {
   Array = "Array",
   ArrayElement = "ArrayElement",
   ElementSelected = "ElementSelected",
+  ScrollList = "ScrollList",
 }
 
 export interface TextfieldRenderOptions extends RenderOptions {
@@ -256,6 +259,7 @@ export interface ArrayRenderOptions extends RenderOptions {
   noRemove?: boolean | null;
   noReorder?: boolean | null;
   editExternal?: boolean | null;
+  childOverrideClass?: string | null;
 }
 
 export interface ArrayElementRenderOptions extends RenderOptions {
@@ -310,6 +314,12 @@ export interface IconSelectionRenderOptions extends RenderOptions {
   type: DataRenderType.IconSelector;
 }
 
+export interface ScrollListRenderOptions extends RenderOptions {
+  type: DataRenderType.ScrollList;
+  bottomActionId?: string;
+  refreshActionId?: string;
+}
+
 export interface GroupedControlsDefinition extends ControlDefinition {
   type: ControlDefinitionType.Group;
   compoundField?: string | null;
@@ -344,11 +354,19 @@ export enum GroupRenderType {
   Wizard = "Wizard",
   Dialog = "Dialog",
   Contents = "Contents",
+  Accordion = "Accordion",
+}
+
+export interface AccordionRenderer extends GroupRenderOptions {
+  type: GroupRenderType.Accordion;
+  defaultExpanded?: boolean | null;
+  expandStateField?: string | null;
 }
 
 export interface DialogRenderOptions extends GroupRenderOptions {
   type: GroupRenderType.Dialog;
   title?: string | null;
+  portalHost?: string | null;
 }
 
 export interface StandardGroupRenderer extends GroupRenderOptions {
@@ -366,10 +384,11 @@ export interface GroupElementRenderer extends GroupRenderOptions {
   value: any;
 }
 
-export interface GridRenderer extends GroupRenderOptions {
+export interface GridRendererOptions extends GroupRenderOptions {
   type: GroupRenderType.Grid;
   columns?: number | null;
   rowClass?: string | null;
+  cellClass?: string | null;
 }
 
 export interface TabsRenderOptions extends GroupRenderOptions {
@@ -422,6 +441,12 @@ export interface CustomDisplay extends DisplayData {
   customId: string;
 }
 
+export enum ControlDisableType {
+  None = "None",
+  Self = "Self",
+  Global = "Global",
+}
+
 export interface ActionControlDefinition extends ControlDefinition {
   type: ControlDefinitionType.Action;
   actionId: string;
@@ -429,6 +454,7 @@ export interface ActionControlDefinition extends ControlDefinition {
   icon?: IconReference | null;
   actionStyle?: ActionStyle | null;
   iconPlacement?: IconPlacement | null;
+  disableType?: ControlDisableType | null;
 }
 
 export enum ActionStyle {
@@ -471,7 +497,7 @@ export function visitControlDefinition<A>(
 }
 export function isGridRenderer(
   options: GroupRenderOptions,
-): options is GridRenderer {
+): options is GridRendererOptions {
   return options.type === GroupRenderType.Grid;
 }
 
@@ -487,9 +513,13 @@ export function isDialogRenderer(
   return options.type === GroupRenderType.Dialog;
 }
 
-export function isInlineRenderer(
+export function isAccordionRenderer(
   options: GroupRenderOptions,
-): options is GridRenderer {
+): options is AccordionRenderer {
+  return options.type === GroupRenderType.Accordion;
+}
+
+export function isInlineRenderer(options: GroupRenderOptions): boolean {
   return options.type === GroupRenderType.Inline;
 }
 
@@ -652,7 +682,7 @@ export function fontAwesomeIcon(icon: string) {
  * @returns True if the control definition is readonly, false otherwise.
  */
 export function isControlReadonly(c: ControlDefinition): boolean {
-  return isDataControl(c) && !!c.readonly;
+  return !!c.readonly;
 }
 
 /**
@@ -661,7 +691,7 @@ export function isControlReadonly(c: ControlDefinition): boolean {
  * @returns True if the control definition is disabled, false otherwise.
  */
 export function isControlDisabled(c: ControlDefinition): boolean {
-  return isDataControl(c) && !!c.disabled;
+  return !!c.disabled;
 }
 
 /**

package/src/defaultSchemaInterface.ts

@@ -109,7 +109,7 @@ export class DefaultSchemaInterface implements SchemaInterface {
           ? new Date("1970-01-01T" + value).toLocaleTimeString()
           : undefined;
       case FieldType.Bool:
-        return this.boolStrings[value ? 1 : 0];
+        return value != null ? this.boolStrings[value ? 1 : 0] : undefined;
       default:
         return value != null ? value.toString() : undefined;
     }
@@ -122,7 +122,8 @@ export class DefaultSchemaInterface implements SchemaInterface {
   }
 
   valueLength(field: SchemaField, value: any): number {
-    return (value && value?.length) ?? 0;
+    const len = value?.length;
+    return typeof len === "number" ? len : 0;
   }
 
   compareValue(field: SchemaField, v1: unknown, v2: unknown): number {
@@ -135,7 +136,7 @@ export class DefaultSchemaInterface implements SchemaInterface {
       case FieldType.String:
         return (v1 as string).localeCompare(v2 as string);
       case FieldType.Bool:
-        return (v1 as boolean) ? ((v2 as boolean) ? 0 : 1) : -1;
+        return v1 === v2 ? 0 : !v1 ? -1 : 1;
       case FieldType.Int:
       case FieldType.Double:
         return (v1 as number) - (v2 as number);

package/src/evalExpression.ts

@@ -8,12 +8,13 @@ import {
 } from "./entityExpression";
 import {
   AsyncEffect,
+  ChangeListenerFunc,
   CleanupScope,
   collectChanges,
+  Control,
   createAsyncEffect,
   createSyncEffect,
   trackedValue,
-  Value,
 } from "@astroapps/controls";
 import { schemaDataForFieldRef, SchemaDataNode } from "./schemaDataNode";
 import { SchemaInterface } from "./schemaInterface";
@@ -27,7 +28,7 @@ export interface ExpressionEvalContext {
   returnResult: (k: unknown) => void;
   dataNode: SchemaDataNode;
   schemaInterface: SchemaInterface;
-  variables?: Value<Record<string, any> | undefined>;
+  variables?: (changes: ChangeListenerFunc<any>) => Record<string, any>;
   runAsync(effect: () => void): void;
 }
 
@@ -91,15 +92,17 @@ export const jsonataEval: ExpressionEval<JsonataExpression> = (
   });
 
   async function runJsonata(effect: AsyncEffect<any>, signal: AbortSignal) {
-    const bindings = collectChanges(
-      effect.collectUsage,
-      () => variables?.value,
-    );
+    const trackedVars = variables?.(effect.collectUsage);
     const evalResult = await parsedJsonata.fields.expr.value.evaluate(
       trackedValue(rootData, effect.collectUsage),
-      bindings,
+      trackedVars,
     );
-    // console.log(parsedJsonata.fields.fullExpr.value, evalResult, bindings);
+    // console.log(
+    //   rootData,
+    //   parsedJsonata.fields.fullExpr.current.value,
+    //   evalResult,
+    //   trackedVars,
+    // );
     collectChanges(effect.collectUsage, () => returnResult(evalResult));
   }
 
@@ -118,3 +121,30 @@ export const defaultEvaluators: Record<string, ExpressionEval<any>> = {
   [ExpressionType.Jsonata]: jsonataEval,
   [ExpressionType.UUID]: uuidEval,
 };
+
+export function createEvalExpr(
+  evalExpression: (e: EntityExpression, ctx: ExpressionEvalContext) => void,
+  context: Omit<ExpressionEvalContext, "returnResult" | "scope">,
+) {
+  function evalExpr<A>(
+    scope: CleanupScope,
+    init: A,
+    nk: Control<A>,
+    e: EntityExpression | undefined,
+    coerce: (t: unknown) => any,
+  ): boolean {
+    nk.value = init;
+    if (e?.type) {
+      evalExpression(e, {
+        returnResult: (r) => {
+          nk.value = coerce(r);
+        },
+        scope,
+        ...context,
+      });
+      return true;
+    }
+    return false;
+  }
+  return evalExpr;
+}