@astroapps/forms-core 1.2.3 → 2.0.0

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./controlDefinition";
+export * from "./controlBuilder";
 export * from "./entityExpression";
 export * from "./schemaNode";
 export * from "./schemaBuilder";
@@ -8,5 +9,8 @@ export * from "./schemaValidator";
 export * from "./schemaDataNode";
 export * from "./defaultSchemaInterface";
 export * from "./formNode";
-export * from "./formState";
+export * from "./formStateNode";
+export * from "./evalExpression";
 export * from "./util";
+export * from "./overrideProxy";
+export * from "./resolveChildren";

package/src/overrideProxy.ts

@@ -0,0 +1,40 @@
+import { Control, getCurrentFields } from "@astroapps/controls";
+
+export function createOverrideProxy<
+  A extends object,
+  B extends Record<string, any>,
+>(proxyFor: A, handlers: Control<B>): A {
+  const overrides = getCurrentFields(handlers);
+  const allOwn = Reflect.ownKeys(proxyFor);
+  Reflect.ownKeys(overrides).forEach((k) => {
+    if (!allOwn.includes(k)) allOwn.push(k);
+  });
+  return new Proxy(proxyFor, {
+    get(target: A, p: string | symbol, receiver: any): any {
+      if (Object.hasOwn(overrides, p)) {
+        const nv = overrides[p as keyof B]!.value;
+        if (nv !== NoOverride) return nv;
+      }
+      return Reflect.get(target, p, receiver);
+    },
+    ownKeys(target: A): ArrayLike<string | symbol> {
+      return allOwn;
+    },
+    has(target: A, p: string | symbol): boolean {
+      return Reflect.has(proxyFor, p) || Reflect.has(overrides, p);
+    },
+    getOwnPropertyDescriptor(target, k) {
+      if (Object.hasOwn(overrides, k))
+        return {
+          enumerable: true,
+          configurable: true,
+        };
+      return Reflect.getOwnPropertyDescriptor(target, k);
+    },
+  });
+}
+
+class NoValue {}
+export const NoOverride = new NoValue();
+
+export type KeysOfUnion<T> = T extends T ? keyof T : never;

package/src/resolveChildren.ts

@@ -0,0 +1,141 @@
+import {
+  ChangeListenerFunc,
+  CleanupScope,
+  Control,
+  trackedValue,
+} from "@astroapps/controls";
+import {
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  DataRenderType,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  isDataControl,
+} from "./controlDefinition";
+import { SchemaDataNode } from "./schemaDataNode";
+import { FormNode } from "./formNode";
+import { createScopedComputed } from "./util";
+import { SchemaInterface } from "./schemaInterface";
+import { FieldOption } from "./schemaField";
+import { FormStateNode } from "./formStateNode";
+import { groupedControl } from "./controlBuilder";
+
+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 function defaultResolveChildNodes(
+  formStateNode: FormStateNode,
+): ChildNodeSpec[] {
+  const {
+    resolved,
+    dataNode: data,
+    schemaInterface,
+    parent,
+    form: node,
+  } = formStateNode;
+  if (!node) return [];
+  const def = resolved.definition;
+  if (isDataControl(def)) {
+    if (!data) return [];
+    const type = def.renderOptions?.type;
+    if (type === DataRenderType.CheckList || type === DataRenderType.Radio) {
+      const n = node.getChildNodes();
+      if (n.length > 0 && resolved.fieldOptions) {
+        return resolved.fieldOptions.map((x) => ({
+          childKey: x.value?.toString(),
+          create: (scope, meta) => {
+            meta["fieldOptionValue"] = x.value;
+            const vars = createScopedComputed(scope, () => {
+              return {
+                option: x,
+                optionSelected: isOptionSelected(schemaInterface, x, data),
+              };
+            });
+            return {
+              definition: {
+                type: ControlDefinitionType.Group,
+                groupOptions: {
+                  type: GroupRenderType.Contents,
+                },
+              } as GroupedControlsDefinition,
+              parent,
+              node,
+              variables: (changes) => ({
+                formData: trackedValue(vars, changes),
+              }),
+            };
+          },
+        }));
+      }
+      return [];
+    }
+    if (data.schema.field.collection && data.elementIndex == null)
+      return resolveArrayChildren(data, node);
+  }
+  return node.getChildNodes().map((x) => ({
+    childKey: x.id,
+    create: () => ({
+      node: x,
+      parent: data ?? parent,
+      definition: x.definition,
+    }),
+  }));
+}
+
+export function resolveArrayChildren(
+  data: SchemaDataNode,
+  node: FormNode,
+  adjustChild?: (elem: Control<any>, index: number) => Partial<ChildNodeInit>,
+): ChildNodeSpec[] {
+  const childNodes = node.getChildNodes();
+  const childCount = childNodes.length;
+  const singleChild = childCount === 1 ? childNodes[0] : null;
+  return data.control.as<any[]>().elements.map((x, i) => ({
+    childKey: x.uniqueId,
+    create: () => ({
+      definition: !childCount
+        ? ({
+            type: ControlDefinitionType.Data,
+            field: ".",
+            hideTitle: true,
+            renderOptions: { type: DataRenderType.Standard },
+          } as DataControlDefinition)
+        : singleChild
+          ? singleChild.definition
+          : groupedControl([]),
+      node: singleChild ?? node,
+      parent: data!.getChildElement(i),
+      ...(adjustChild?.(x, i) ?? {}),
+    }),
+  }));
+}
+
+function isOptionSelected(
+  schemaInterface: SchemaInterface,
+  option: FieldOption,
+  data: SchemaDataNode,
+) {
+  if (data.schema.field.collection) {
+    return !!data.control.as<any[] | undefined>().value?.includes(option.value);
+  }
+  return (
+    schemaInterface.compareValue(
+      data.schema.field,
+      data.control.value,
+      option.value,
+    ) === 0
+  );
+}

package/src/schemaBuilder.ts

@@ -283,6 +283,9 @@ export function mergeFields(
   value: any,
   newFields: SchemaField[],
 ): SchemaField[] {
+  if (name === "*") {
+    return newFields.reduce((af, x) => mergeField(x, af), fields);
+  }
   const withType = fields.map((x) =>
     x.isTypeField ? addFieldOption(x, name, value) : x,
   );

package/src/schemaDataNode.ts

@@ -186,3 +186,15 @@ export function hideDisplayOnly(
     schemaInterface.isEmptyValue(context.schema.field, context.control?.value)
   );
 }
+
+export function getLoadingControl(data: Control<any>): Control<boolean> {
+  return ensureMetaValue(data, "loading", () => newControl(false));
+}
+
+export function getRefreshingControl(data: Control<any>): Control<boolean> {
+  return ensureMetaValue(data, "refreshing", () => newControl(false));
+}
+
+export function getHasMoreControl(data: Control<any>): Control<boolean> {
+  return ensureMetaValue(data, "hasMore", () => newControl(false));
+}

package/src/schemaNode.ts

@@ -9,7 +9,10 @@ import {
 export interface SchemaTreeLookup {
   getSchema(schemaId: string): SchemaNode | undefined;
 
-  getSchemaTree(schemaId: string, additional?: SchemaField[]): SchemaTree | undefined;
+  getSchemaTree(
+    schemaId: string,
+    additional?: SchemaField[],
+  ): SchemaTree | undefined;
 }
 
 export abstract class SchemaTree {
@@ -63,6 +66,7 @@ export class SchemaNode {
     public field: SchemaField,
     public tree: SchemaTree,
     public parent?: SchemaNode,
+    private getChildFields?: () => SchemaField[],
   ) {}
 
   getSchema(schemaId: string): SchemaNode | undefined {
@@ -70,6 +74,7 @@ export class SchemaNode {
   }
 
   getUnresolvedFields(): SchemaField[] {
+    if (this.getChildFields) return this.getChildFields();
     return isCompoundField(this.field) ? this.field.children : [];
   }
 
@@ -228,6 +233,54 @@ export function schemaForFieldPath(
   return schema;
 }
 
+export function schemaForDataPath(
+  fieldPath: string[],
+  schema: SchemaNode,
+): DataPathNode {
+  let i = 0;
+  let element = schema.field.collection;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode: SchemaNode | undefined;
+    if (nextField == ".") {
+      i++;
+      continue;
+    } else if (nextField == "..") {
+      if (element) {
+        element = false;
+        i++;
+        continue;
+      }
+      childNode = schema.parent;
+    } else {
+      childNode = schema.getChildNode(nextField);
+    }
+    if (!childNode) {
+      childNode = createSchemaNode(
+        missingField(nextField),
+        schema.tree,
+        schema,
+      );
+    } else {
+      element = childNode.field.collection;
+    }
+    schema = childNode;
+    i++;
+  }
+  return { node: schema, element: !!element };
+}
+
+export function getParentDataPath({
+  node,
+  element,
+}: DataPathNode): DataPathNode | undefined {
+  if (element) return { node, element: false };
+  const parent = node.parent;
+  return parent
+    ? { node: parent, element: !!parent.field.collection }
+    : undefined;
+}
+
 export function getSchemaNodePath(node: SchemaNode) {
   const paths: string[] = [];
   let curNode: SchemaNode | undefined = node;
@@ -283,3 +336,8 @@ export function relativeSegmentPath(
 
   return "../".repeat(upLevels) + downPath;
 }
+
+export interface DataPathNode {
+  node: SchemaNode;
+  element: boolean;
+}

package/src/schemaValidator.ts

@@ -30,3 +30,22 @@ export interface DateValidator extends SchemaValidator {
   fixedDate?: string | null;
   daysFromCurrent?: number | null;
 }
+
+export function jsonataValidator(expr: string): JsonataValidator {
+  return { type: ValidatorType.Jsonata, expression: expr };
+}
+
+export function dateValidator(
+  comparison: DateComparison,
+  fixedDate?: string | null,
+  daysFromCurrent?: number | null,
+): DateValidator {
+  return { type: ValidatorType.Date, comparison, fixedDate, daysFromCurrent };
+}
+
+export function lengthValidator(
+  min?: number | null,
+  max?: number | null,
+): LengthValidator {
+  return { type: ValidatorType.Length, min, max };
+}

package/src/validators.ts

@@ -6,13 +6,10 @@ import {
   SchemaValidator,
   ValidatorType,
 } from "./schemaValidator";
-import {
-  ControlDefinition,
-  DataControlDefinition,
-  isDataControl,
-} from "./controlDefinition";
+import { ControlDefinition, isDataControl } from "./controlDefinition";
 import { SchemaDataNode } from "./schemaDataNode";
 import {
+  CleanupScope,
   Control,
   ControlChange,
   createCleanupScope,
@@ -21,12 +18,10 @@ import {
 } from "@astroapps/controls";
 import { ValidationMessageType } from "./schemaField";
 import { SchemaInterface } from "./schemaInterface";
-
-import { FormContextOptions } from "./formState";
-import { FormNode } from "./formNode";
 import { jsonataEval } from "./evalExpression";
 import { ExpressionType } from "./entityExpression";
 import { createScopedComputed } from "./util";
+import { FormStateBaseImpl, VariablesFunc } from "./formStateNode";
 
 export interface ValidationEvalContext {
   addSync(validate: (value: unknown) => string | undefined | null): void;
@@ -35,7 +30,7 @@ export interface ValidationEvalContext {
   parentData: SchemaDataNode;
   data: SchemaDataNode;
   schemaInterface: SchemaInterface;
-  formContext: Control<FormContextOptions>;
+  variables?: VariablesFunc;
   runAsync(af: () => void): void;
 }
 
@@ -60,7 +55,7 @@ export const jsonataValidator: ValidatorEval<JsonataValidator> = (
         context.data.control.setError("jsonata", v?.toString());
       },
       schemaInterface: context.schemaInterface,
-      variables: context.formContext.fields.variables,
+      variables: context.variables,
       runAsync: context.runAsync,
     },
   );
@@ -155,12 +150,14 @@ export function createValidators(
       context.addSync((v) => {
         const field = context.data.schema.field;
         return schemaInterface.isEmptyValue(field, v)
-          ? schemaInterface.validationMessageText(
-              field,
-              ValidationMessageType.NotEmpty,
-              false,
-              true,
-            )
+          ? def.requiredErrorText
+            ? def.requiredErrorText
+            : schemaInterface.validationMessageText(
+                field,
+                ValidationMessageType.NotEmpty,
+                false,
+                true,
+              )
           : null;
       });
     }
@@ -169,19 +166,16 @@ export function createValidators(
 }
 
 export function setupValidation(
-  controlImpl: Control<FormContextOptions>,
+  scope: CleanupScope,
+  variables: VariablesFunc | undefined,
   definition: ControlDefinition,
   dataNode: Control<SchemaDataNode | undefined>,
   schemaInterface: SchemaInterface,
   parent: SchemaDataNode,
-  formNode: FormNode,
-  hidden: Control<boolean>,
+  visible: Control<boolean | null>,
   runAsync: (af: () => void) => void,
 ) {
-  const validationEnabled = createScopedComputed(
-    controlImpl,
-    () => !hidden.value,
-  );
+  const validationEnabled = createScopedComputed(scope, () => !!visible.value);
   const validatorsScope = createCleanupScope();
   createEffect(
     () => {
@@ -189,7 +183,7 @@ export function setupValidation(
       const dn = dataNode.value;
       if (dn) {
         let syncValidations: ((v: unknown) => string | undefined | null)[] = [];
-        createValidators(formNode.definition, {
+        createValidators(definition, {
           data: dn,
           parentData: parent,
           validationEnabled,
@@ -200,7 +194,7 @@ export function setupValidation(
           addCleanup(cleanup: () => void) {
             validatorsScope.addCleanup(cleanup);
           },
-          formContext: controlImpl,
+          variables,
           runAsync,
         });
 
@@ -224,6 +218,6 @@ export function setupValidation(
       }
     },
     (c) => {},
-    controlImpl,
+    scope,
   );
 }

package/tsconfig.test.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react",
+    "outDir": "lib"
+  },
+  "include": ["test/**/*.ts", "test/**/*.tsx"],
+  "exclude": ["node_modules", "lib"]
+}

package/lib/formState.d.ts

@@ -1,48 +0,0 @@
-import { FormNode } from "./formNode";
-import { SchemaDataNode } from "./schemaDataNode";
-import { ControlDefinition } from "./controlDefinition";
-import { SchemaInterface } from "./schemaInterface";
-import { FieldOption } from "./schemaField";
-import { Control } from "@astroapps/controls";
-import { ExpressionEval, ExpressionEvalContext } from "./evalExpression";
-import { EntityExpression } from "./entityExpression";
-export interface ControlState {
-    definition: ControlDefinition;
-    schemaInterface: SchemaInterface;
-    dataNode?: SchemaDataNode | undefined;
-    display?: string;
-    stateId?: string;
-    style?: object;
-    layoutStyle?: object;
-    allowedOptions?: any[];
-    readonly: boolean;
-    hidden: boolean;
-    disabled: boolean;
-    clearHidden: boolean;
-    variables: Record<string, any>;
-    meta: Control<Record<string, any>>;
-}
-export interface FormContextOptions {
-    readonly?: boolean | null;
-    hidden?: boolean | null;
-    disabled?: boolean | null;
-    clearHidden?: boolean;
-    stateKey?: string;
-    variables?: Record<string, any>;
-}
-/**
- * Interface representing the form context data.
- */
-export interface FormContextData {
-    option?: FieldOption;
-    optionSelected?: boolean;
-}
-export interface FormState {
-    getControlState(parent: SchemaDataNode, formNode: FormNode, context: FormContextOptions, runAsync: (af: () => void) => void): ControlState;
-    cleanup(): void;
-    evalExpression(expr: EntityExpression, context: ExpressionEvalContext): void;
-    getExistingControlState(parent: SchemaDataNode, formNode: FormNode, stateKey?: string): ControlState | undefined;
-}
-export declare function getControlStateId(parent: SchemaDataNode, formNode: FormNode, stateKey?: string): string;
-export declare function createFormState(schemaInterface: SchemaInterface, evaluators?: Record<string, ExpressionEval<any>>): FormState;
-export declare function createOverrideProxy<A extends object, B extends Record<string, any>>(proxyFor: A, handlers: Control<B>): A;