@react-typed-forms/schemas 8.2.0 → 9.0.0

package/src/hooks.tsx

@@ -1,373 +0,0 @@
-import {
-  ControlDefinition,
-  DataExpression,
-  DataMatchExpression,
-  DynamicPropertyType,
-  EntityExpression,
-  ExpressionType,
-  isDataControlDefinition,
-  JsonataExpression,
-  SchemaField,
-  SchemaInterface,
-} from "./types";
-import { useCallback, useEffect, useMemo, useRef } from "react";
-import {
-  addAfterChangesCallback,
-  collectChanges,
-  Control,
-  makeChangeTracker,
-  useComputed,
-  useControl,
-  useRefState,
-} from "@react-typed-forms/core";
-
-import {
-  ControlDataContext,
-  defaultValueForField,
-  findField,
-  getDisplayOnlyOptions,
-  getTypeField,
-  isControlReadonly,
-  jsonPathString,
-  lookupChildControl,
-  useUpdatedRef,
-} from "./util";
-import jsonata from "jsonata";
-import { trackedStructure, useCalculatedControl } from "./internal";
-import { DataContext } from "./controlRender";
-
-export type UseEvalExpressionHook = (
-  expr: EntityExpression | undefined,
-) => EvalExpressionHook | undefined;
-
-export function useEvalVisibilityHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  definition: ControlDefinition,
-  schemaField?: SchemaField,
-): EvalExpressionHook<boolean> {
-  const dynamicVisibility = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.Visible,
-    useEvalExpressionHook,
-  );
-  const r = useUpdatedRef({ schemaField, definition });
-  return useCallback(
-    (ctx) => {
-      const { schemaField, definition } = r.current;
-      return (
-        dynamicVisibility?.(ctx) ??
-        useComputed(
-          () =>
-            matchesType(ctx, schemaField?.onlyForTypes) &&
-            (!schemaField ||
-              !hideDisplayOnly(
-                ctx,
-                schemaField,
-                definition,
-                ctx.schemaInterface,
-              )),
-        )
-      );
-    },
-    [dynamicVisibility, r],
-  );
-}
-
-export function useEvalReadonlyHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  definition: ControlDefinition,
-): EvalExpressionHook<boolean> {
-  const dynamicReadonly = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.Readonly,
-    useEvalExpressionHook,
-  );
-  const r = useUpdatedRef(definition);
-  return useCallback(
-    (ctx) => {
-      if (dynamicReadonly) return dynamicReadonly(ctx);
-      return useCalculatedControl(() => isControlReadonly(r.current));
-    },
-    [dynamicReadonly, r],
-  );
-}
-
-export function useEvalStyleHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  property: DynamicPropertyType,
-  definition: ControlDefinition,
-): EvalExpressionHook<React.CSSProperties> {
-  const dynamicStyle = useEvalDynamicHook(
-    definition,
-    property,
-    useEvalExpressionHook,
-  );
-  return useCallback(
-    (ctx) => {
-      if (dynamicStyle) return dynamicStyle(ctx);
-      return useControl(undefined);
-    },
-    [dynamicStyle],
-  );
-}
-
-export function useEvalAllowedOptionsHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  definition: ControlDefinition,
-): EvalExpressionHook<any[]> {
-  const dynamicAllowed = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.AllowedOptions,
-    useEvalExpressionHook,
-  );
-  return useCallback(
-    (ctx) => {
-      if (dynamicAllowed) return dynamicAllowed(ctx);
-      return useControl([]);
-    },
-    [dynamicAllowed],
-  );
-}
-
-export function useEvalDisabledHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  definition: ControlDefinition,
-): EvalExpressionHook<boolean> {
-  const dynamicDisabled = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.Disabled,
-    useEvalExpressionHook,
-  );
-  return useCallback(
-    (ctx) => {
-      if (dynamicDisabled) return dynamicDisabled(ctx);
-      return useControl(false);
-    },
-    [dynamicDisabled],
-  );
-}
-
-export function useEvalDisplayHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  definition: ControlDefinition,
-): (
-  groupContext: ControlDataContext,
-) => Control<string | undefined> | undefined {
-  const dynamicDisplay = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.Display,
-    useEvalExpressionHook,
-  );
-  return useCallback((ctx) => dynamicDisplay?.(ctx), [dynamicDisplay]);
-}
-export function useEvalDefaultValueHook(
-  useEvalExpressionHook: UseEvalExpressionHook,
-  definition: ControlDefinition,
-  schemaField?: SchemaField,
-): EvalExpressionHook {
-  const dynamicValue = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.DefaultValue,
-    useEvalExpressionHook,
-  );
-  const r = useUpdatedRef({ definition, schemaField });
-  return useCallback(
-    (ctx) => {
-      const { definition, schemaField } = r.current;
-      return dynamicValue?.(ctx) ?? useComputed(calcDefault);
-      function calcDefault() {
-        const [required, dcv] = isDataControlDefinition(definition)
-          ? [definition.required, definition.defaultValue]
-          : [false, undefined];
-        return (
-          dcv ??
-          (schemaField
-            ? defaultValueForField(schemaField, required)
-            : undefined)
-        );
-      }
-    },
-    [dynamicValue, r],
-  );
-}
-
-export type EvalExpressionHook<A = any> = (
-  groupContext: ControlDataContext,
-) => Control<A | undefined>;
-
-function useDataExpression(
-  fvExpr: DataExpression,
-  fields: SchemaField[],
-  data: DataContext,
-) {
-  const refField = findField(fields, fvExpr.field);
-  const otherField = refField
-    ? lookupChildControl(data, refField.field)
-    : undefined;
-  return useCalculatedControl(() => otherField?.value);
-}
-
-function useDataMatchExpression(
-  fvExpr: DataMatchExpression,
-  fields: SchemaField[],
-  data: DataContext,
-) {
-  const refField = findField(fields, fvExpr.field);
-  const otherField = refField
-    ? lookupChildControl(data, refField.field)
-    : undefined;
-  return useComputed(() => {
-    const fv = otherField?.value;
-    return Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value;
-  });
-}
-
-export function defaultEvalHooks(
-  expr: EntityExpression,
-  context: ControlDataContext,
-) {
-  switch (expr.type) {
-    case ExpressionType.Jsonata:
-      return useJsonataExpression(
-        (expr as JsonataExpression).expression,
-        context,
-      );
-    case ExpressionType.Data:
-      return useDataExpression(expr as DataExpression, context.fields, context);
-    case ExpressionType.DataMatch:
-      return useDataMatchExpression(
-        expr as DataMatchExpression,
-        context.fields,
-        context,
-      );
-    default:
-      return useControl(undefined);
-  }
-}
-
-export const defaultUseEvalExpressionHook =
-  makeEvalExpressionHook(defaultEvalHooks);
-
-export function makeEvalExpressionHook(
-  f: (expr: EntityExpression, context: ControlDataContext) => Control<any>,
-): (expr: EntityExpression | undefined) => EvalExpressionHook | undefined {
-  return (expr) => {
-    const r = useUpdatedRef(expr);
-    const cb = useCallback(
-      (ctx: ControlDataContext) => {
-        const expr = r.current!;
-        return f(expr, ctx);
-      },
-      [expr?.type, r],
-    );
-    return expr ? cb : undefined;
-  };
-}
-
-export function useEvalDynamicHook(
-  definition: ControlDefinition,
-  type: DynamicPropertyType,
-  useEvalExpressionHook: (
-    expr: EntityExpression | undefined,
-  ) => EvalExpressionHook | undefined,
-): EvalExpressionHook | undefined {
-  const expression = definition.dynamic?.find((x) => x.type === type);
-  return useEvalExpressionHook(expression?.expr);
-}
-
-export function matchesType(
-  context: ControlDataContext,
-  types?: string[] | null,
-) {
-  if (types == null || types.length === 0) return true;
-  const typeField = getTypeField(context);
-  return typeField && types.includes(typeField.value);
-}
-
-export function hideDisplayOnly(
-  context: ControlDataContext,
-  field: SchemaField,
-  definition: ControlDefinition,
-  schemaInterface: SchemaInterface,
-) {
-  const displayOptions = getDisplayOnlyOptions(definition);
-  return (
-    displayOptions &&
-    !displayOptions.emptyText &&
-    schemaInterface.isEmptyValue(
-      field,
-      lookupChildControl(context, field.field)?.value,
-    )
-  );
-}
-
-export function useJsonataExpression(
-  jExpr: string,
-  dataContext: DataContext,
-  bindings?: () => Record<string, any>,
-): Control<any> {
-  const pathString = jsonPathString(dataContext.path, (x) => `#$i[${x}]`);
-  const fullExpr = pathString ? pathString + ".(" + jExpr + ")" : jExpr;
-  const compiledExpr = useMemo(() => {
-    try {
-      return jsonata(fullExpr);
-    } catch (e) {
-      console.error(e);
-      return jsonata("null");
-    }
-  }, [fullExpr]);
-  const control = useControl();
-  const listenerRef = useRef<() => void>();
-  const [ref] = useRefState(() =>
-    makeChangeTracker(() => {
-      const l = listenerRef.current;
-      if (l) {
-        listenerRef.current = undefined;
-        addAfterChangesCallback(() => {
-          l();
-          listenerRef.current = l;
-        });
-      }
-    }),
-  );
-  useEffect(() => {
-    listenerRef.current = apply;
-    apply();
-    async function apply() {
-      const [collect, updateSubscriptions] = ref.current;
-      try {
-        const bindingData = bindings
-          ? collectChanges(collect, bindings)
-          : undefined;
-        control.value = await compiledExpr.evaluate(
-          trackedStructure(dataContext.data, collect),
-          bindingData,
-        );
-      } finally {
-        updateSubscriptions();
-      }
-    }
-    return () => ref.current[1](true);
-  }, [compiledExpr]);
-  return control;
-}
-
-export function useEvalLabelText(
-  useExpr: UseEvalExpressionHook,
-  definition: ControlDefinition,
-): EvalExpressionHook<string | null> {
-  const dynamicValue = useEvalDynamicHook(
-    definition,
-    DynamicPropertyType.Label,
-    useExpr,
-  );
-  return useCallback(
-    (ctx) => {
-      if (dynamicValue) {
-        return dynamicValue(ctx);
-      }
-      return useControl(null);
-    },
-    [dynamicValue],
-  );
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from "./types";
-export * from "./schemaBuilder";
-export * from "./controlBuilder";
-export * from "./controlRender";
-export * from "./util";
-export * from "./renderers";
-export * from "./tailwind";
-export * from "./validators";
-export * from "./hooks";
-export * from "./schemaInterface";

package/src/internal.ts

@@ -1,48 +0,0 @@
-import {
-  ChangeListenerFunc,
-  Control,
-  ControlChange,
-  useControl,
-  useControlEffect,
-} from "@react-typed-forms/core";
-
-export function useCalculatedControl<V>(calculate: () => V): Control<V> {
-  const c = useControl(calculate);
-  useControlEffect(calculate, (v) => (c.value = v));
-  return c;
-}
-
-export function cc(n: string | null | undefined): string | undefined {
-  return n ? n : undefined;
-}
-
-export function trackedStructure<A>(
-  c: Control<A>,
-  tracker: ChangeListenerFunc<any>,
-): A {
-  const cc = c.current;
-  const cv = cc.value;
-  if (cv == null) {
-    tracker(c, ControlChange.Structure);
-    return cv;
-  }
-  if (typeof cv !== "object") {
-    tracker(c, ControlChange.Value);
-    return cv;
-  }
-  return new Proxy(cv, {
-    get(target: object, p: string | symbol, receiver: any): any {
-      if (Array.isArray(cv)) {
-        tracker(c, ControlChange.Structure);
-        if (typeof p === "symbol" || p[0] >= "9" || p[0] < "0")
-          return Reflect.get(cv, p);
-        const nc = (cc.elements as any)[p];
-        if (typeof nc === "function") return nc;
-        if (nc == null) return null;
-        return trackedStructure(nc, tracker);
-      }
-      if (p in cv) return trackedStructure((cc.fields as any)[p], tracker);
-      return undefined;
-    },
-  }) as A;
-}