@react-typed-forms/schemas 15.1.3 → 15.2.0

package/src/hooks.tsx

@@ -31,6 +31,11 @@ import {
 import jsonata from "jsonata";
 import { v4 as uuidv4 } from "uuid";
 import { DynamicHookGenerator, HookDep, toDepString } from "./dynamicHooks";
+import {
+  schemaDataForFieldRef,
+  SchemaDataNode,
+  SchemaInterface,
+} from "./schemaField";
 import {
   DataExpression,
   DataMatchExpression,
@@ -39,8 +44,6 @@ import {
   JsonataExpression,
   NotEmptyExpression,
 } from "./entityExpression";
-import { SchemaInterface } from "./schemaInterface";
-import { schemaDataForFieldRef, SchemaDataNode } from "./schemaDataNode";
 
 export type EvalExpressionHook<A = any> = DynamicHookGenerator<
   Control<A | undefined>,
@@ -330,10 +333,7 @@ export function matchesType(context: SchemaDataNode): boolean {
   const typeNode = parent.schema
     .getChildNodes()
     .find((x) => x.field.isTypeField);
-  if (typeNode == null) {
-    console.warn("No type field found for", parent.schema);
-    return false;
-  }
+  if (typeNode == null) return true;
   const typeField = parent.getChild(typeNode).control as Control<string>;
   return typeField && types.includes(typeField.value);
 }
@@ -373,7 +373,7 @@ export function useJsonataExpression(
     }
   }, [fullExpr]);
   const control = useControl();
-  const listenerRef = useRef<(() => void) | undefined>(undefined);
+  const listenerRef = useRef<() => void>();
   const updateRef = useRef(0);
   const [ref] = useRefState(
     () =>

package/src/index.ts

@@ -12,7 +12,3 @@ export * from "./dynamicHooks";
 export * from "./schemaValidator";
 export * from "./schemaField";
 export * from "./entityExpression";
-export * from "./formNode";
-export * from "./schemaInterface";
-export * from "./schemaDataNode";
-export * from "./schemaNode";

package/src/renderers.tsx

@@ -36,6 +36,7 @@ export interface DefaultRenderers {
   renderLayout: LayoutRendererRegistration;
   visibility: VisibilityRendererRegistration;
   extraRenderers: RendererRegistration[];
+  renderText: (props: ReactNode) => ReactNode;
   html: HtmlComponents;
 }
 

package/src/schemaField.ts

@@ -1,4 +1,6 @@
 import { SchemaValidator } from "./schemaValidator";
+import { Control, ControlSetup, newControl } from "@react-typed-forms/core";
+import { EntityExpression } from "./entityExpression";
 
 export type EqualityFunc = (a: any, b: any) => boolean;
 
@@ -114,6 +116,146 @@ export enum ValidationMessageType {
   NotBeforeDate = "NotBeforeDate",
 }
 
+/**
+ * Interface for schema-related operations.
+ */
+export interface SchemaInterface {
+  /**
+   * Checks if the value of a field is empty.
+   * @param field The schema field.
+   * @param value The value to check.
+   * @returns True if the value is empty, false otherwise.
+   */
+  isEmptyValue(field: SchemaField, value: any): boolean;
+
+  /**
+   * Gets the text representation of a field's value.
+   * @param field The schema field.
+   * @param value The value to convert.
+   * @param element Indicates if the value is an element, optional.
+   * @returns The text representation of the value.
+   */
+  textValue(
+    field: SchemaField,
+    value: any,
+    element?: boolean,
+  ): string | undefined;
+
+  /**
+   * Gets the length of a control's value.
+   * @param field The schema field.
+   * @param control The control to check.
+   * @returns The length of the control's value.
+   */
+  controlLength(field: SchemaField, control: Control<any>): number;
+
+  /**
+   * Gets the length of a field's value.
+   * @param field The schema field.
+   * @param value The value to check.
+   * @returns The length of the value.
+   */
+  valueLength(field: SchemaField, value: any): number;
+
+  /**
+   * Gets the data options for a schema data node.
+   * @param node The schema data node.
+   * @returns The data options.
+   */
+  getDataOptions(node: SchemaDataNode): FieldOption[] | null | undefined;
+
+  /**
+   * Gets the node options for a schema node.
+   * @param node The schema node.
+   * @returns The node options.
+   */
+  getNodeOptions(node: SchemaNode): FieldOption[] | null | undefined;
+
+  /**
+   * Gets the options for a schema field.
+   * @param field The schema field.
+   * @returns The field options.
+   */
+  getOptions(field: SchemaField): FieldOption[] | undefined | null;
+
+  /**
+   * Gets the filter options for a schema data node and field.
+   * @param array The schema data node.
+   * @param field The schema node.
+   * @returns The filter options.
+   */
+  getFilterOptions(
+    array: SchemaDataNode,
+    field: SchemaNode,
+  ): FieldOption[] | undefined | null;
+
+  /**
+   * Parses a string value to milliseconds.
+   * @param field The schema field.
+   * @param v The string value to parse.
+   * @returns The parsed value in milliseconds.
+   */
+  parseToMillis(field: SchemaField, v: string): number;
+
+  /**
+   * Gets the validation message text for a field.
+   * @param field The schema field.
+   * @param messageType The type of validation message.
+   * @param actual The actual value.
+   * @param expected The expected value.
+   * @returns The validation message text.
+   */
+  validationMessageText(
+    field: SchemaField,
+    messageType: ValidationMessageType,
+    actual: any,
+    expected: any,
+  ): string;
+
+  /**
+   * Compares two values of a field.
+   * @param field The schema field.
+   * @param v1 The first value.
+   * @param v2 The second value.
+   * @returns The comparison result.
+   */
+  compareValue(field: SchemaField, v1: unknown, v2: unknown): number;
+
+  /**
+   * Gets the search text for a field's value.
+   * @param field The schema field.
+   * @param value The value to search.
+   * @returns The search text.
+   */
+  searchText(field: SchemaField, value: any): string;
+
+  makeEqualityFunc(field: SchemaNode, element?: boolean): EqualityFunc;
+
+  makeControlSetup(field: SchemaNode, element?: boolean): ControlSetup<any>;
+}
+
+export interface SchemaTreeLookup {
+  getSchema(schemaId: string): SchemaNode | undefined;
+}
+
+export interface SchemaNode extends SchemaTreeLookup {
+  id: string;
+  field: SchemaField;
+  getChildNode(field: string): SchemaNode | undefined;
+  getChildNodes(noRecurse?: boolean, withParent?: SchemaNode): SchemaNode[];
+  parent?: SchemaNode;
+}
+
+export interface SchemaDataNode {
+  id: string;
+  schema: SchemaNode;
+  elementIndex?: number;
+  control: Control<any>;
+  parent?: SchemaDataNode;
+  getChild(schemaNode: SchemaNode): SchemaDataNode;
+  getChildElement(index: number): SchemaDataNode;
+}
+
 export function findField(
   fields: SchemaField[],
   field: string,
@@ -129,10 +271,267 @@ export function isCompoundField(sf: SchemaField): sf is CompoundField {
   return sf.type === FieldType.Compound;
 }
 
-export function missingField(field: string): SchemaField {
+function missingField(field: string): SchemaField {
   return { field: "__missing", type: FieldType.Any, displayName: field };
 }
 
+function nodeForSchema(
+  field: SchemaField,
+  lookup: SchemaTreeLookup,
+  parent: SchemaNode | undefined,
+): SchemaNode {
+  const node = {
+    id: parent ? parent.id + "/" + field.field : field.field,
+    field,
+    getSchema: lookup.getSchema,
+    parent,
+    getChildNode,
+    getChildNodes,
+  };
+  return node;
+
+  function getChildNode(fieldName: string) {
+    if (isCompoundField(field) && !field.schemaRef && !field.treeChildren) {
+      const childField = field.children.find((x) => x.field === fieldName);
+      return childField ? nodeForSchema(childField, lookup, node) : undefined;
+    }
+    return getChildNodes(false, node).find((x) => x.field.field === fieldName);
+  }
+
+  function getChildNodes(
+    noRecurse?: boolean,
+    withParent?: SchemaNode,
+  ): SchemaNode[] {
+    if (isCompoundField(field)) {
+      if (field.treeChildren) {
+        return noRecurse
+          ? []
+          : parent!.getChildNodes(false, withParent ?? node);
+      }
+      const otherRef = field.schemaRef && lookup.getSchema(field.schemaRef);
+      if (otherRef) return otherRef.getChildNodes(false, withParent ?? node);
+      return field.children.map((x) =>
+        nodeForSchema(x, lookup, withParent ?? node),
+      );
+    }
+    return [];
+  }
+}
+
+export function createSchemaLookup<A extends Record<string, SchemaField[]>>(
+  schemaMap: A,
+): {
+  getSchema(schemaId: keyof A): SchemaNode;
+} {
+  const lookup = {
+    getSchema,
+  };
+  return lookup;
+
+  function getSchema(schemaId: keyof A): SchemaNode {
+    const fields = schemaMap[schemaId];
+    if (fields) {
+      return rootSchemaNode(fields, lookup);
+    }
+    return undefined!;
+  }
+}
+
+export function makeSchemaDataNode(
+  schema: SchemaNode,
+  control: Control<unknown>,
+  parent?: SchemaDataNode,
+  elementIndex?: number,
+): SchemaDataNode {
+  const indexId = typeof elementIndex === "number" ? "/" + elementIndex : "";
+  const dataNode = {
+    id:
+      (parent ? parent.id + "/" + schema.field.field : schema.field.field) +
+      indexId,
+    schema,
+    control,
+    parent,
+    elementIndex,
+    getChild,
+    getChildElement,
+  };
+  return dataNode;
+
+  function getChild(childNode: SchemaNode): SchemaDataNode {
+    const objControl = control as Control<Record<string, unknown>>;
+    if (objControl && objControl.current.isNull) {
+      objControl.value = {};
+    }
+    return makeSchemaDataNode(
+      childNode,
+      objControl?.fields[childNode.field.field],
+      dataNode,
+    );
+  }
+
+  function getChildElement(elementIndex: number): SchemaDataNode {
+    return makeSchemaDataNode(
+      schema,
+      (control as Control<unknown[]>)?.elements?.[elementIndex],
+      dataNode,
+      elementIndex,
+    );
+  }
+}
+
+export function schemaDataForFieldRef(
+  fieldRef: string | undefined,
+  schema: SchemaDataNode,
+): SchemaDataNode {
+  return schemaDataForFieldPath(fieldRef?.split("/") ?? [], schema);
+}
+
+export function schemaForFieldRef(
+  fieldRef: string | undefined,
+  schema: SchemaNode,
+): SchemaNode {
+  return schemaForFieldPath(fieldRef?.split("/") ?? [], schema);
+}
+
+export function traverseSchemaPath<A>(
+  fieldPath: string[],
+  schema: SchemaNode,
+  acc: A,
+  next: (acc: A, node: SchemaNode) => A,
+): A {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode =
+      nextField === ".." ? schema.parent : schema.getChildNode(nextField);
+    if (!childNode) {
+      childNode = nodeForSchema(missingField(nextField), schema, schema);
+    }
+    acc = next(acc, childNode);
+    schema = childNode;
+    i++;
+  }
+  return acc;
+}
+
+export function traverseData(
+  fieldPath: string[],
+  root: SchemaNode,
+  data: { [k: string]: any },
+): unknown {
+  return traverseSchemaPath(
+    fieldPath,
+    root,
+    data,
+    (acc, n) => acc?.[n.field.field] as any,
+  );
+}
+
+export function schemaDataForFieldPath(
+  fieldPath: string[],
+  dataNode: SchemaDataNode,
+): SchemaDataNode {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let nextNode =
+      nextField === ".." ? dataNode.parent : lookupField(nextField);
+    nextNode ??= makeSchemaDataNode(
+      nodeForSchema(missingField(nextField), dataNode.schema, dataNode.schema),
+      newControl(undefined),
+    );
+    dataNode = nextNode;
+    i++;
+  }
+  return dataNode;
+
+  function lookupField(field: string): SchemaDataNode | undefined {
+    const childNode = dataNode.schema.getChildNode(field);
+    if (childNode) {
+      return dataNode.getChild(childNode);
+    }
+    return undefined;
+  }
+}
+
+export function schemaForFieldPath(
+  fieldPath: string[],
+  schema: SchemaNode,
+): SchemaNode {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode =
+      nextField === ".." ? schema.parent : schema.getChildNode(nextField);
+    if (!childNode) {
+      childNode = nodeForSchema(missingField(nextField), schema, schema);
+    }
+    schema = childNode;
+    i++;
+  }
+  return schema;
+}
+
+export function rootSchemaNode(
+  fields: SchemaField[],
+  lookup: SchemaTreeLookup = {
+    getSchema(schemaId: string): SchemaNode | undefined {
+      return undefined;
+    },
+  },
+): SchemaNode {
+  return nodeForSchema(
+    {
+      type: FieldType.Compound,
+      field: "",
+      children: fields,
+    } as CompoundField,
+    lookup,
+    undefined,
+  );
+}
+
+export function getSchemaNodePath(node: SchemaNode) {
+  const paths: string[] = [];
+  let curNode: SchemaNode | undefined = node;
+  while (curNode) {
+    paths.push(curNode.field.field);
+    curNode = curNode.parent;
+  }
+  return paths.reverse();
+}
+
+export function isCompoundNode(node: SchemaNode) {
+  return isCompoundField(node.field);
+}
+
+/**
+ * Returns the relative path from a parent node to a child node.
+ * @param parent
+ * @param child
+ */
+export function relativePath(parent: SchemaNode, child: SchemaNode): string {
+  // return the path from child to parent
+  if (parent.id === child.id) return "";
+
+  const parentPath = getSchemaNodePath(parent);
+  const childPath = getSchemaNodePath(child);
+
+  let i = 0;
+  while (
+    i < parentPath.length &&
+    i < childPath.length &&
+    parentPath[i] === childPath[i]
+  ) {
+    i++;
+  }
+
+  const upLevels = parentPath.length - i;
+  const downPath = childPath.slice(i).join("/");
+
+  return "../".repeat(upLevels) + downPath;
+}
+
 export enum SchemaTags {
   NoControl = "_NoControl",
   HtmlEditor = "_HtmlEditor",