@astroapps/forms-core 1.0.0

package/src/defaultSchemaInterface.ts

@@ -0,0 +1,201 @@
+import {
+  EqualityFunc,
+  FieldOption,
+  FieldType,
+  SchemaField,
+  ValidationMessageType,
+} from "./schemaField";
+import { SchemaInterface } from "./schemaInterface";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaNode } from "./schemaNode";
+import { Control, ControlSetup } from "@astroapps/controls";
+
+export class DefaultSchemaInterface implements SchemaInterface {
+  constructor(
+    protected boolStrings: [string, string] = ["No", "Yes"],
+    protected parseDateTime: (s: string) => number = (s) => Date.parse(s),
+  ) {}
+
+  parseToMillis(field: SchemaField, v: string): number {
+    return this.parseDateTime(v);
+  }
+
+  validationMessageText(
+    field: SchemaField,
+    messageType: ValidationMessageType,
+    actual: any,
+    expected: any,
+  ): string {
+    switch (messageType) {
+      case ValidationMessageType.NotEmpty:
+        return "Please enter a value";
+      case ValidationMessageType.MinLength:
+        return "Length must be at least " + expected;
+      case ValidationMessageType.MaxLength:
+        return "Length must be less than " + expected;
+      case ValidationMessageType.NotBeforeDate:
+        return `Date must not be before ${new Date(expected).toDateString()}`;
+      case ValidationMessageType.NotAfterDate:
+        return `Date must not be after ${new Date(expected).toDateString()}`;
+      default:
+        return "Unknown error";
+    }
+  }
+
+  getDataOptions(node: SchemaDataNode): FieldOption[] | null | undefined {
+    return this.getNodeOptions(node.schema);
+  }
+
+  getNodeOptions(node: SchemaNode): FieldOption[] | null | undefined {
+    return this.getOptions(node.field);
+  }
+
+  getOptions({ options }: SchemaField): FieldOption[] | null | undefined {
+    return options && options.length > 0 ? options : null;
+  }
+
+  getFilterOptions(
+    array: SchemaDataNode,
+    field: SchemaNode,
+  ): FieldOption[] | undefined | null {
+    return this.getNodeOptions(field);
+  }
+
+  isEmptyValue(f: SchemaField, value: any): boolean {
+    if (f.collection)
+      return Array.isArray(value) ? value.length === 0 : value == null;
+    switch (f.type) {
+      case FieldType.String:
+      case FieldType.DateTime:
+      case FieldType.Date:
+      case FieldType.Time:
+        return !value;
+      default:
+        return value == null;
+    }
+  }
+
+  searchText(field: SchemaField, value: any): string {
+    return this.textValue(field, value)?.toLowerCase() ?? "";
+  }
+
+  textValueForData(dataNode: SchemaDataNode): string | undefined {
+    const options = this.getDataOptions(dataNode);
+    return this.textValue(
+      dataNode.schema.field,
+      dataNode.control.value,
+      dataNode.elementIndex != null,
+      options,
+    );
+  }
+  textValue(
+    field: SchemaField,
+    value: any,
+    element?: boolean | undefined,
+    options?: FieldOption[] | null,
+  ): string | undefined {
+    const actualOptions = options ?? this.getOptions(field);
+    const option = actualOptions?.find((x) => x.value === value);
+    if (option) return option.name;
+    switch (field.type) {
+      case FieldType.Date:
+        return value ? new Date(value).toLocaleDateString() : undefined;
+      case FieldType.DateTime:
+        return value
+          ? new Date(this.parseToMillis(field, value)).toLocaleString()
+          : undefined;
+      case FieldType.Time:
+        return value
+          ? new Date("1970-01-01T" + value).toLocaleTimeString()
+          : undefined;
+      case FieldType.Bool:
+        return this.boolStrings[value ? 1 : 0];
+      default:
+        return value != null ? value.toString() : undefined;
+    }
+  }
+
+  controlLength(f: SchemaField, control: Control<any>): number {
+    return f.collection
+      ? (control.elements?.length ?? 0)
+      : this.valueLength(f, control.value);
+  }
+
+  valueLength(field: SchemaField, value: any): number {
+    return (value && value?.length) ?? 0;
+  }
+
+  compareValue(field: SchemaField, v1: unknown, v2: unknown): number {
+    if (v1 == null) return v2 == null ? 0 : 1;
+    if (v2 == null) return -1;
+    switch (field.type) {
+      case FieldType.Date:
+      case FieldType.DateTime:
+      case FieldType.Time:
+      case FieldType.String:
+        return (v1 as string).localeCompare(v2 as string);
+      case FieldType.Bool:
+        return (v1 as boolean) ? ((v2 as boolean) ? 0 : 1) : -1;
+      case FieldType.Int:
+      case FieldType.Double:
+        return (v1 as number) - (v2 as number);
+      default:
+        return 0;
+    }
+  }
+
+  compoundFieldSetup(f: SchemaNode): [string, ControlSetup<any>][] {
+    return f.getChildNodes().map((x) => {
+      const { field } = x.field;
+      return [field, this.makeControlSetup(x)];
+    });
+  }
+
+  compoundFieldEquality(f: SchemaNode): [string, EqualityFunc][] {
+    return f.getChildNodes().map((x) => {
+      const { field } = x.field;
+      return [field, (a, b) => this.makeEqualityFunc(x)(a[field], b[field])];
+    });
+  }
+
+  makeEqualityFunc(field: SchemaNode, element?: boolean): EqualityFunc {
+    if (field.field.collection && !element) {
+      const elemEqual = this.makeEqualityFunc(field, true);
+      return (a, b) => {
+        if (a === b) return true;
+        if (a == null || b == null) return false;
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+          if (!elemEqual(a[i], b[i])) return false;
+        }
+        return true;
+      };
+    }
+    switch (field.field.type) {
+      case FieldType.Compound:
+        const allChecks = this.compoundFieldEquality(field);
+        return (a, b) =>
+          a === b ||
+          (a != null && b != null && allChecks.every((x) => x[1](a, b)));
+      default:
+        return (a, b) => a === b;
+    }
+  }
+  makeControlSetup(field: SchemaNode, element?: boolean): ControlSetup<any> {
+    let setup: ControlSetup<any> = {
+      equals: this.makeEqualityFunc(field, element),
+    };
+    if (field.field.collection && !element) {
+      setup.elems = this.makeControlSetup(field, true);
+      return setup;
+    }
+    switch (field.field.type) {
+      case FieldType.Compound:
+        setup.fields = Object.fromEntries(this.compoundFieldSetup(field));
+    }
+    return setup;
+  }
+}
+
+export const defaultSchemaInterface: SchemaInterface =
+  new DefaultSchemaInterface();

package/src/entityExpression.ts

@@ -0,0 +1,39 @@
+export interface EntityExpression {
+  type: string;
+}
+
+export enum ExpressionType {
+  Jsonata = "Jsonata",
+  Data = "Data",
+  DataMatch = "FieldValue",
+  UserMatch = "UserMatch",
+  NotEmpty = "NotEmpty",
+  UUID = "UUID",
+}
+
+export interface JsonataExpression extends EntityExpression {
+  type: ExpressionType.Jsonata;
+  expression: string;
+}
+
+export interface DataExpression extends EntityExpression {
+  type: ExpressionType.Data;
+  field: string;
+}
+
+export interface DataMatchExpression extends EntityExpression {
+  type: ExpressionType.DataMatch;
+  field: string;
+  value: any;
+}
+
+export interface NotEmptyExpression extends EntityExpression {
+  type: ExpressionType.NotEmpty;
+  field: string;
+  empty?: boolean | null;
+}
+
+export interface UserMatchExpression extends EntityExpression {
+  type: ExpressionType.UserMatch;
+  userMatch: string;
+}

package/src/evalExpression.ts

@@ -0,0 +1,118 @@
+import {
+  DataExpression,
+  DataMatchExpression,
+  EntityExpression,
+  ExpressionType,
+  JsonataExpression,
+  NotEmptyExpression,
+} from "./entityExpression";
+import {
+  AsyncEffect,
+  CleanupScope,
+  collectChanges,
+  createAsyncEffect,
+  createSyncEffect,
+  trackedValue,
+  Value,
+} from "@astroapps/controls";
+import { schemaDataForFieldRef, SchemaDataNode } from "./schemaDataNode";
+import { SchemaInterface } from "./schemaInterface";
+import jsonata from "jsonata";
+import { getJsonPath, getRootDataNode } from "./controlDefinition";
+import { v4 as uuidv4 } from "uuid";
+import { createScopedComputed, jsonPathString } from "./util";
+
+export interface ExpressionEvalContext {
+  scope: CleanupScope;
+  returnResult: (k: unknown) => void;
+  dataNode: SchemaDataNode;
+  schemaInterface: SchemaInterface;
+  variables?: Value<Record<string, any> | undefined>;
+}
+
+export type ExpressionEval<T extends EntityExpression> = (
+  expr: T,
+  context: ExpressionEvalContext,
+) => void;
+
+const dataEval: ExpressionEval<DataExpression> = (
+  fvExpr,
+  { dataNode: node, returnResult, scope },
+) => {
+  createSyncEffect(() => {
+    const otherField = schemaDataForFieldRef(fvExpr.field, node);
+    returnResult(otherField.control?.value);
+  }, scope);
+};
+const dataMatchEval: ExpressionEval<DataMatchExpression> = (
+  matchExpr,
+  { dataNode, returnResult, scope },
+) => {
+  createSyncEffect(() => {
+    const otherField = schemaDataForFieldRef(matchExpr.field, dataNode);
+    const fv = otherField?.control.value;
+    returnResult(
+      Array.isArray(fv) ? fv.includes(matchExpr.value) : fv === matchExpr.value,
+    );
+  }, scope);
+};
+
+const notEmptyEval: ExpressionEval<NotEmptyExpression> = (
+  expr,
+  { returnResult, dataNode, scope, schemaInterface },
+) => {
+  createSyncEffect(() => {
+    const otherField = schemaDataForFieldRef(expr.field, dataNode);
+    const fv = otherField.control?.value;
+    const field = otherField.schema.field;
+    const empty = !!expr.empty;
+    returnResult(field && empty === schemaInterface.isEmptyValue(field, fv));
+  }, scope);
+};
+
+export const jsonataEval: ExpressionEval<JsonataExpression> = (
+  expr,
+  { scope, returnResult, dataNode, variables },
+) => {
+  const path = getJsonPath(dataNode);
+  const pathString = jsonPathString(path, (x) => `#$i[${x}]`);
+  const rootData = getRootDataNode(dataNode).control;
+
+  const parsedJsonata = createScopedComputed(scope, () => {
+    const jExpr = expr.expression;
+    const fullExpr = pathString ? pathString + ".(" + jExpr + ")" : jExpr;
+    try {
+      return { expr: jsonata(fullExpr ? fullExpr : "null"), fullExpr };
+    } catch (e) {
+      console.error(e);
+      return { expr: jsonata("null"), fullExpr };
+    }
+  });
+
+  async function runJsonata(effect: AsyncEffect<any>, signal: AbortSignal) {
+    const bindings = collectChanges(
+      effect.collectUsage,
+      () => variables?.value,
+    );
+    const evalResult = await parsedJsonata.fields.expr.value.evaluate(
+      trackedValue(rootData, effect.collectUsage),
+      bindings,
+    );
+    // console.log(parsedJsonata.fields.fullExpr.value, evalResult, bindings);
+    collectChanges(effect.collectUsage, () => returnResult(evalResult));
+  }
+
+  createAsyncEffect(runJsonata, scope);
+};
+
+export const uuidEval: ExpressionEval<EntityExpression> = (_, ctx) => {
+  ctx.returnResult(uuidv4());
+};
+
+export const defaultEvaluators: Record<string, ExpressionEval<any>> = {
+  [ExpressionType.DataMatch]: dataMatchEval,
+  [ExpressionType.Data]: dataEval,
+  [ExpressionType.NotEmpty]: notEmptyEval,
+  [ExpressionType.Jsonata]: jsonataEval,
+  [ExpressionType.UUID]: uuidEval,
+};

package/src/formNode.ts

@@ -0,0 +1,249 @@
+import {
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  isDataControl,
+  isGroupControl,
+} from "./controlDefinition";
+import { schemaDataForFieldPath, SchemaDataNode } from "./schemaDataNode";
+
+export type ControlMap = { [k: string]: ControlDefinition };
+
+export class FormNode {
+  constructor(
+    public id: string,
+    public definition: ControlDefinition,
+    public tree: FormTree,
+    public parent?: FormNode,
+  ) {}
+
+  visit<A>(visitFn: (n: FormNode) => A | undefined): A | undefined {
+    const res = visitFn(this);
+    if (res !== undefined) return res;
+    const children = this.getUnresolvedChildNodes();
+    for (const child of children) {
+      const res = child.visit(visitFn);
+      if (res !== undefined) return res;
+    }
+    return undefined;
+  }
+
+  getResolvedChildren(): ControlDefinition[] {
+    const childRefId = this.definition.childRefId;
+    const parent = childRefId ? this.tree.getByRefId(childRefId) : undefined;
+    return (parent ?? this.definition)?.children ?? [];
+  }
+
+  createChildNode(childId: string, childDef: ControlDefinition) {
+    return new FormNode(
+      this.tree.getChildId(this.id, childId, childDef),
+      childDef,
+      this.tree,
+      this,
+    );
+  }
+
+  getChildNodes(): FormNode[] {
+    const resolved = this.getResolvedChildren();
+    return resolved.map((x, i) => this.createChildNode(i.toString(), x));
+  }
+
+  getUnresolvedChildNodes(): FormNode[] {
+    return (
+      this.definition.children?.map((x, i) =>
+        this.createChildNode(i.toString(), x),
+      ) ?? []
+    );
+  }
+}
+
+export interface FormTreeLookup {
+  getForm(formId: string): FormTree | undefined;
+}
+
+export abstract class FormTree implements FormTreeLookup {
+  abstract rootNode: FormNode;
+
+  abstract getByRefId(id: string): ControlDefinition | undefined;
+
+  abstract getForm(formId: string): FormTree | undefined;
+
+  getChildId(
+    parentId: string,
+    childId: string,
+    control: ControlDefinition,
+  ): string {
+    return parentId + "/" + childId;
+  }
+}
+
+function getControlIds(
+  definition: ControlDefinition,
+): [string, ControlDefinition][] {
+  const childEntries = definition.children?.flatMap(getControlIds) ?? [];
+  return !definition.id
+    ? childEntries
+    : [[definition.id, definition], ...childEntries];
+}
+
+export function createControlMap(control: ControlDefinition): ControlMap {
+  return Object.fromEntries(getControlIds(control));
+}
+
+class FormTreeImpl extends FormTree {
+  controlMap: ControlMap;
+  rootNode: FormNode;
+
+  constructor(
+    private forms: FormTreeLookup,
+    root: ControlDefinition,
+  ) {
+    super();
+    this.rootNode = new FormNode("", root, this);
+    this.controlMap = createControlMap(root);
+  }
+
+  getByRefId(id: string): ControlDefinition | undefined {
+    return this.controlMap[id];
+  }
+
+  getForm(formId: string): FormTree | undefined {
+    return this.forms.getForm(formId);
+  }
+}
+
+export function legacyFormNode(definition: ControlDefinition) {
+  return createFormTree([definition]).rootNode.getChildNodes()[0];
+}
+
+export function createFormTree(
+  controls: ControlDefinition[],
+  getForm: FormTreeLookup = { getForm: () => undefined },
+): FormTree {
+  return new FormTreeImpl(getForm, {
+    type: ControlDefinitionType.Group,
+    children: controls,
+    groupOptions: {
+      type: GroupRenderType.Standard,
+      hideTitle: true,
+    },
+  } as GroupedControlsDefinition);
+}
+
+export function createFormLookup<A extends Record<string, ControlDefinition[]>>(
+  formMap: A,
+): {
+  getForm(formId: keyof A): FormTree;
+} {
+  const lookup = {
+    getForm,
+  };
+  const forms = Object.fromEntries(
+    Object.entries(formMap).map(([k, v]) => [k, createFormTree(v, lookup)]),
+  );
+  return lookup;
+
+  function getForm(formId: keyof A): FormTree {
+    return forms[formId as string];
+  }
+}
+
+export function fieldPathForDefinition(
+  c: ControlDefinition,
+): string[] | undefined {
+  const fieldName = isGroupControl(c)
+    ? c.compoundField
+    : isDataControl(c)
+      ? c.field
+      : undefined;
+  return fieldName?.split("/");
+}
+
+export function lookupDataNode(
+  c: ControlDefinition,
+  parentNode: SchemaDataNode,
+) {
+  const fieldNamePath = fieldPathForDefinition(c);
+  return fieldNamePath
+    ? schemaDataForFieldPath(fieldNamePath, parentNode)
+    : undefined;
+}
+
+/**
+ * @deprecated use visitFormNodeData instead
+ */
+export function visitControlDataArray<A>(
+  controls: ControlDefinition[] | undefined | null,
+  context: SchemaDataNode,
+  cb: (
+    definition: DataControlDefinition,
+    node: SchemaDataNode,
+  ) => A | undefined,
+): A | undefined {
+  if (!controls) return undefined;
+  for (const c of controls) {
+    const r = visitControlData(c, context, cb);
+    if (r !== undefined) return r;
+  }
+  return undefined;
+}
+
+/**
+ * @deprecated use visitFormDataInContext instead
+ */
+export function visitControlData<A>(
+  definition: ControlDefinition,
+  ctx: SchemaDataNode,
+  cb: (
+    definition: DataControlDefinition,
+    field: SchemaDataNode,
+  ) => A | undefined,
+): A | undefined {
+  return visitFormDataInContext(ctx, legacyFormNode(definition), (n, d) =>
+    cb(d, n),
+  );
+}
+
+export type ControlDataVisitor<A> = (
+  dataNode: SchemaDataNode,
+  definition: DataControlDefinition,
+) => A | undefined;
+
+export function visitFormData<A>(
+  node: FormNode,
+  dataNode: SchemaDataNode,
+  cb: ControlDataVisitor<A>,
+  notSelf?: boolean,
+): A | undefined {
+  const def = node.definition;
+  const result = !notSelf && isDataControl(def) ? cb(dataNode, def) : undefined;
+  if (result !== undefined) return result;
+  if (dataNode.elementIndex == null && dataNode.schema.field.collection) {
+    const l = dataNode.control.elements.length;
+    for (let i = 0; i < l; i++) {
+      const elemChild = dataNode.getChildElement(i);
+      const elemResult = visitFormData(node, elemChild, cb);
+      if (elemResult !== undefined) return elemResult;
+    }
+    return undefined;
+  }
+  if (dataNode.control.isNull) return undefined;
+  const children = node.getChildNodes();
+  const l = children.length;
+  for (let i = 0; i < l; i++) {
+    const elemResult = visitFormDataInContext(dataNode, children[i], cb);
+    if (elemResult !== undefined) return elemResult;
+  }
+  return undefined;
+}
+
+export function visitFormDataInContext<A>(
+  parentContext: SchemaDataNode,
+  node: FormNode,
+  cb: ControlDataVisitor<A>,
+): A | undefined {
+  const dataNode = lookupDataNode(node.definition, parentContext);
+  return visitFormData(node, dataNode ?? parentContext, cb, !dataNode);
+}