@react-typed-forms/schemas 15.1.3 → 16.0.0

package/src/schemaInterface.ts

@@ -1,135 +0,0 @@
-import { Control, ControlSetup } from "@react-typed-forms/core";
-import {
-  EqualityFunc,
-  FieldOption,
-  SchemaField,
-  ValidationMessageType,
-} from "./schemaField";
-import { SchemaDataNode } from "./schemaDataNode";
-import { SchemaNode } from "./schemaNode";
-
-/**
- * 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.
-   * @param options The field options, optional.
-   * @returns The text representation of the value.
-   */
-  textValue(
-    field: SchemaField,
-    value: any,
-    element?: boolean,
-    options?: FieldOption[],
-  ): string | undefined;
-
-  /**
-   * Gets the text representation of a field's value for a data node.
-   * @param dataNode
-   */
-  textValueForData(dataNode: SchemaDataNode): 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>;
-}

package/src/schemaNode.ts

@@ -1,279 +0,0 @@
-import {
-  CompoundField,
-  FieldType,
-  isCompoundField,
-  missingField,
-  SchemaField,
-} from "./schemaField";
-
-export interface SchemaTreeLookup {
-  getSchema(schemaId: string): SchemaNode | undefined;
-
-  getSchemaTree(schemaId: string): SchemaTree | undefined;
-}
-
-export abstract class SchemaTree {
-  abstract rootNode: SchemaNode;
-
-  abstract getSchemaTree(schemaId: string): SchemaTree | undefined;
-
-  createChildNode(parent: SchemaNode, field: SchemaField): SchemaNode {
-    return new SchemaNode(parent.id + "/" + field.field, field, this, parent);
-  }
-
-  getSchema(schemaId: string): SchemaNode | undefined {
-    return this.getSchemaTree(schemaId)?.rootNode;
-  }
-}
-
-class SchemaTreeImpl extends SchemaTree {
-  rootNode: SchemaNode;
-
-  getSchemaTree(schemaId: string): SchemaTree | undefined {
-    return this.lookup?.getSchemaTree(schemaId);
-  }
-
-  constructor(
-    rootFields: SchemaField[],
-    private lookup?: SchemaTreeLookup,
-  ) {
-    super();
-    this.rootNode = new SchemaNode(
-      "",
-      {
-        type: FieldType.Compound,
-        field: "",
-        children: rootFields,
-      } as CompoundField,
-      this,
-    );
-  }
-}
-
-export function createSchemaTree(
-  rootFields: SchemaField[],
-  lookup?: SchemaTreeLookup,
-): SchemaTree {
-  return new SchemaTreeImpl(rootFields, lookup);
-}
-
-export class SchemaNode {
-  public constructor(
-    public id: string,
-    public field: SchemaField,
-    public tree: SchemaTree,
-    public parent?: SchemaNode,
-  ) {}
-
-  getSchema(schemaId: string): SchemaNode | undefined {
-    return this.tree.getSchema(schemaId);
-  }
-
-  getUnresolvedFields(): SchemaField[] {
-    return isCompoundField(this.field) ? this.field.children : [];
-  }
-
-  getResolvedParent(): SchemaNode | undefined {
-    const f = this.field;
-    if (!isCompoundField(f)) return undefined;
-    const parentNode = f.schemaRef
-      ? this.tree.getSchema(f.schemaRef)
-      : f.treeChildren
-        ? this.parent?.getResolvedParent()
-        : undefined;
-    return parentNode ?? this;
-  }
-
-  getResolvedFields(): SchemaField[] {
-    const resolvedParent = this.getResolvedParent();
-    return resolvedParent?.getUnresolvedFields() ?? [];
-  }
-
-  getChildNodes(): SchemaNode[] {
-    const node = this;
-    return node.getResolvedFields().map((x) => node.createChildNode(x));
-  }
-
-  getChildField(field: string): SchemaField {
-    return (
-      this.getResolvedFields().find((x) => x.field === field) ??
-      missingField(field)
-    );
-  }
-
-  createChildNode(field: SchemaField): SchemaNode {
-    return this.tree.createChildNode(this, field);
-  }
-
-  getChildNode(field: string): SchemaNode {
-    return this.createChildNode(this.getChildField(field));
-  }
-}
-
-export function resolveSchemaNode(
-  node: SchemaNode,
-  fieldSegment: string,
-): SchemaNode | undefined {
-  if (fieldSegment == ".") return node;
-  if (fieldSegment == "..") return node.parent;
-  return node.getChildNode(fieldSegment);
-}
-
-export function createSchemaNode(
-  field: SchemaField,
-  lookup: SchemaTree,
-  parent: SchemaNode | undefined,
-): SchemaNode {
-  return new SchemaNode(
-    parent ? parent.id + "/" + field.field : field.field,
-    field,
-    lookup,
-    parent,
-  );
-}
-
-export function createSchemaLookup<A extends Record<string, SchemaField[]>>(
-  schemaMap: A,
-): {
-  getSchema(schemaId: keyof A): SchemaNode;
-  getSchemaTree(schemaId: keyof A): SchemaTree;
-} {
-  const lookup = {
-    getSchemaTree,
-    getSchema,
-  };
-  return lookup;
-
-  function getSchema(schemaId: keyof A): SchemaNode {
-    return getSchemaTree(schemaId)!.rootNode;
-  }
-
-  function getSchemaTree(schemaId: keyof A): SchemaTree {
-    const fields = schemaMap[schemaId];
-    if (fields) {
-      return new SchemaTreeImpl(fields, lookup);
-    }
-    return undefined!;
-  }
-}
-
-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 = resolveSchemaNode(schema, nextField);
-    if (!childNode) {
-      childNode = createSchemaNode(
-        missingField(nextField),
-        schema.tree,
-        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 schemaForFieldPath(
-  fieldPath: string[],
-  schema: SchemaNode,
-): SchemaNode {
-  let i = 0;
-  while (i < fieldPath.length) {
-    const nextField = fieldPath[i];
-    let childNode = resolveSchemaNode(schema, nextField);
-    if (!childNode) {
-      childNode = createSchemaNode(
-        missingField(nextField),
-        schema.tree,
-        schema,
-      );
-    }
-    schema = childNode;
-    i++;
-  }
-  return schema;
-}
-
-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 getSchemaNodePathString(node: SchemaNode) {
-  return getSchemaNodePath(node).join("/");
-}
-
-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);
-  return relativeSegmentPath(parentPath, childPath);
-}
-
-/**
- * Returns the relative path from a parent node to a child node.
- * @param parentPath
- * @param childPath
- */
-export function relativeSegmentPath(
-  parentPath: string[],
-  childPath: string[],
-): string {
-  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;
-}

package/src/schemaValidator.ts

@@ -1,32 +0,0 @@
-export enum ValidatorType {
-  Jsonata = "Jsonata",
-  Date = "Date",
-  Length = "Length",
-}
-
-export interface SchemaValidator {
-  type: string;
-}
-
-export interface JsonataValidator extends SchemaValidator {
-  type: ValidatorType.Jsonata;
-  expression: string;
-}
-
-export interface LengthValidator extends SchemaValidator {
-  type: ValidatorType.Length;
-  min?: number | null;
-  max?: number | null;
-}
-
-export enum DateComparison {
-  NotBefore = "NotBefore",
-  NotAfter = "NotAfter",
-}
-
-export interface DateValidator extends SchemaValidator {
-  type: ValidatorType.Date;
-  comparison: DateComparison;
-  fixedDate?: string | null;
-  daysFromCurrent?: number | null;
-}

package/src/validators.ts

@@ -1,217 +0,0 @@
-import {
-  ControlDefinition,
-  DataControlDefinition,
-  isDataControl,
-  ControlDataContext,
-  getRootDataNode,
-  getJsonPath,
-} from "./controlDefinition";
-import {
-  Control,
-  useValidator,
-  useValueChangeEffect,
-} from "@react-typed-forms/core";
-import { useCallback } from "react";
-import { useUpdatedRef } from "./util";
-import { useJsonataExpression } from "./hooks";
-import { makeHookDepString } from "./dynamicHooks";
-import {
-  DateComparison,
-  DateValidator,
-  JsonataValidator,
-  LengthValidator,
-  SchemaValidator,
-  ValidatorType,
-} from "./schemaValidator";
-import { FieldType, SchemaField, ValidationMessageType } from "./schemaField";
-
-interface ValidationHookContext {
-  hiddenControl: Control<boolean | null | undefined>;
-  dataContext: ControlDataContext;
-  control: Control<any>;
-}
-
-export interface ValidationContext extends ValidationHookContext {
-  definition: DataControlDefinition;
-  field: SchemaField;
-  index: number;
-}
-
-export function useMakeValidationHook(
-  definition: ControlDefinition,
-  useValidatorFor: (
-    validator: SchemaValidator,
-    ctx: ValidationContext,
-  ) => void = useDefaultValidator,
-): (ctx: ValidationHookContext) => void {
-  const dd = isDataControl(definition) ? definition : undefined;
-
-  const refData = useUpdatedRef({ dd, useValidatorFor });
-  const depString = dd
-    ? makeHookDepString(dd.validators ?? [], (x) => x.type)
-    : "~";
-  return useCallback(
-    (ctx) => {
-      const { dd } = refData.current;
-      if (!dd) return;
-      const field = ctx.dataContext.dataNode?.schema.field ?? {
-        field: "__missing",
-        type: FieldType.Any,
-      };
-      const {
-        control,
-        hiddenControl,
-        dataContext: { schemaInterface },
-      } = ctx;
-
-      useValueChangeEffect(control, () => control.setError("default", ""));
-      if (dd.required)
-        useValidator(
-          control,
-          (v) => {
-            return !hiddenControl.value &&
-              schemaInterface.isEmptyValue(field, v)
-              ? schemaInterface.validationMessageText(
-                  field,
-                  ValidationMessageType.NotEmpty,
-                  false,
-                  true,
-                )
-              : null;
-          },
-          "required",
-        );
-      dd.validators?.forEach((v, i) =>
-        useValidatorFor(v, { ...ctx, index: i, field, definition: dd }),
-      );
-    },
-    [!!dd, dd?.required, depString, useValidatorFor],
-  );
-}
-
-const useDefaultValidator = (
-  validator: SchemaValidator,
-  ctx: ValidationContext,
-) => {
-  switch (validator.type) {
-    case ValidatorType.Length:
-      useLengthValidator(validator as LengthValidator, ctx);
-      break;
-    case ValidatorType.Jsonata:
-      useJsonataValidator(validator as JsonataValidator, ctx);
-      break;
-    case ValidatorType.Date:
-      useDateValidator(validator as DateValidator, ctx);
-      break;
-  }
-};
-
-export function useJsonataValidator(
-  validator: JsonataValidator,
-  ctx: ValidationContext,
-) {
-  const sdn = ctx.dataContext.parentNode;
-  const errorMsg = useJsonataExpression(
-    validator.expression,
-    getRootDataNode(sdn).control!,
-    getJsonPath(sdn),
-    undefined,
-    (v) => (v == null ? null : typeof v === "string" ? v : JSON.stringify(v)),
-  );
-  useValidator(
-    ctx.control,
-    () => (!ctx.hiddenControl.value ? errorMsg.value : null),
-    "jsonata" + ctx.index,
-  );
-}
-
-export function useLengthValidator(
-  lv: LengthValidator,
-  ctx: ValidationContext,
-) {
-  const {
-    control,
-    dataContext: { schemaInterface },
-    hiddenControl,
-    field,
-  } = ctx;
-  useValidator(
-    control,
-    (v) => {
-      const len = schemaInterface.controlLength(field, control);
-      const hidden = hiddenControl.value;
-      if (hidden) {
-        return undefined;
-      }
-      if (lv.min != null && len < lv.min) {
-        if (field?.collection) {
-          control.setValue((v) =>
-            Array.isArray(v)
-              ? v.concat(Array.from({ length: lv.min! - v.length }))
-              : Array.from({ length: lv.min! }),
-          );
-        } else {
-          return schemaInterface.validationMessageText(
-            field,
-            ValidationMessageType.MinLength,
-            len,
-            lv.min,
-          );
-        }
-      } else if (lv.max != null && len > lv.max) {
-        return schemaInterface.validationMessageText(
-          field,
-          ValidationMessageType.MaxLength,
-          len,
-          lv.max,
-        );
-      }
-      return undefined;
-    },
-    "length" + ctx.index,
-  );
-}
-
-export function useDateValidator(dv: DateValidator, ctx: ValidationContext) {
-  const {
-    control,
-    field,
-    index,
-    dataContext: { schemaInterface },
-  } = ctx;
-  let comparisonDate: number;
-  if (dv.fixedDate) {
-    comparisonDate = schemaInterface.parseToMillis(field, dv.fixedDate);
-  } else {
-    const nowDate = new Date();
-    comparisonDate = Date.UTC(
-      nowDate.getFullYear(),
-      nowDate.getMonth(),
-      nowDate.getDate(),
-    );
-    if (dv.daysFromCurrent) {
-      comparisonDate += dv.daysFromCurrent * 86400000;
-    }
-  }
-  useValidator(
-    control,
-    (v) => {
-      if (v) {
-        const selDate = schemaInterface.parseToMillis(field, v);
-        const notAfter = dv.comparison === DateComparison.NotAfter;
-        if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
-          return schemaInterface.validationMessageText(
-            field,
-            notAfter
-              ? ValidationMessageType.NotAfterDate
-              : ValidationMessageType.NotBeforeDate,
-            selDate,
-            comparisonDate,
-          );
-        }
-      }
-      return null;
-    },
-    "date" + index,
-  );
-}