@astroapps/forms-core 1.0.1

package/src/schemaBuilder.ts

@@ -0,0 +1,318 @@
+import {
+  CompoundField,
+  FieldOption,
+  FieldType,
+  isCompoundField,
+  SchemaField,
+  SchemaMap,
+} from "./schemaField";
+
+export type AllowedSchema<T> = T extends string
+  ? SchemaField & {
+      type:
+        | FieldType.String
+        | FieldType.Date
+        | FieldType.DateTime
+        | FieldType.Time;
+    }
+  : T extends number
+    ? SchemaField & {
+        type: FieldType.Int | FieldType.Double;
+      }
+    : T extends boolean
+      ? SchemaField & {
+          type: FieldType.Bool;
+        }
+      : T extends Array<infer E>
+        ? AllowedSchema<E> & {
+            collection: true;
+          }
+        : T extends { [key: string]: any }
+          ? CompoundField & {
+              type: FieldType.Compound;
+            }
+          : SchemaField & { type: FieldType.Any };
+
+type AllowedField<T, K> = (
+  name: string,
+) => (SchemaField & { type: K }) | AllowedSchema<T>;
+
+export function buildSchema<T, Custom = "">(def: {
+  [K in keyof T]-?: AllowedField<T[K], Custom>;
+}): SchemaField[] {
+  return Object.entries(def).map((x) =>
+    (x[1] as (n: string) => SchemaField)(x[0]),
+  );
+}
+
+export type FieldBuilder<T extends FieldType, K> = (
+  name: string,
+) => Omit<SchemaField, "type"> & { type: T } & K;
+
+export function stringField(
+  displayName: string,
+): FieldBuilder<FieldType.String, {}>;
+
+export function stringField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options: S,
+): FieldBuilder<FieldType.String, S>;
+
+export function stringField(displayName: string, options?: any) {
+  return makeScalarField({
+    type: FieldType.String,
+    displayName,
+    ...options,
+  });
+}
+
+export function stringOptionsField(
+  displayName: string,
+  ...options: FieldOption[]
+) {
+  return makeScalarField({
+    type: FieldType.String as const,
+    displayName,
+    options,
+  });
+}
+
+export function withScalarOptions<
+  S extends SchemaField,
+  S2 extends Partial<SchemaField>,
+>(options: S2, v: (name: string) => S): (name: string) => S & S2 {
+  return (n) => ({ ...v(n), ...options });
+}
+
+export function makeScalarField<S extends Partial<SchemaField>>(
+  options: S,
+): (name: string) => SchemaField & S {
+  return (n) => ({ ...defaultScalarField(n, n), ...options });
+}
+
+export function makeCompoundField<S extends Partial<CompoundField>>(
+  options: S,
+): (name: string) => CompoundField & {
+  type: FieldType.Compound;
+} & S {
+  return (n) => ({ ...defaultCompoundField(n, n, false), ...options });
+}
+
+export function intField(displayName: string): FieldBuilder<FieldType.Int, {}>;
+
+export function intField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options: S,
+): FieldBuilder<FieldType.Int, S>;
+
+export function intField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options?: S,
+) {
+  return makeScalarField({
+    type: FieldType.Int as const,
+    displayName,
+    ...(options as S),
+  });
+}
+
+export function doubleField(
+  displayName: string,
+): FieldBuilder<FieldType.Double, {}>;
+
+export function doubleField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options: S,
+): FieldBuilder<FieldType.Double, S>;
+
+export function doubleField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options?: S,
+) {
+  return makeScalarField({
+    type: FieldType.Double as const,
+    displayName,
+    ...(options as S),
+  });
+}
+
+export function dateField(
+  displayName: string,
+): FieldBuilder<FieldType.Date, {}>;
+
+export function dateField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options: S,
+): FieldBuilder<FieldType.Date, S>;
+
+export function dateField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options?: S,
+) {
+  return makeScalarField({
+    type: FieldType.Date as const,
+    displayName,
+    ...(options as S),
+  });
+}
+
+export function timeField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options?: S,
+) {
+  return makeScalarField({
+    type: FieldType.Time as const,
+    displayName,
+    ...(options as S),
+  });
+}
+
+export function dateTimeField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options?: S,
+) {
+  return makeScalarField({
+    type: FieldType.DateTime as const,
+    displayName,
+    ...(options as S),
+  });
+}
+
+export function boolField(
+  displayName: string,
+): FieldBuilder<FieldType.Bool, {}>;
+
+export function boolField<S extends Partial<SchemaField>>(
+  displayName: string,
+  options: S,
+): FieldBuilder<FieldType.Bool, S>;
+
+export function boolField(displayName: string, options?: any) {
+  return makeScalarField({
+    type: FieldType.Bool as const,
+    displayName,
+    ...options,
+  });
+}
+
+export function compoundField<
+  Other extends Partial<Omit<CompoundField, "type" | "schemaType">>,
+>(
+  displayName: string,
+  fields: SchemaField[],
+  other?: Other,
+): (name: string) => CompoundField & {
+  collection: Other["collection"];
+} {
+  return (field) =>
+    ({
+      ...defaultCompoundField(field, displayName, false),
+      ...other,
+      children: fields,
+    }) as any;
+}
+
+export function defaultScalarField(
+  field: string,
+  displayName: string,
+): Omit<SchemaField, "type"> & {
+  type: FieldType.String;
+} {
+  return {
+    field,
+    displayName,
+    type: FieldType.String,
+  };
+}
+
+export function defaultCompoundField(
+  field: string,
+  displayName: string,
+  collection: boolean,
+): CompoundField & {
+  type: FieldType.Compound;
+} {
+  return {
+    field,
+    displayName,
+    type: FieldType.Compound,
+    collection,
+    children: [],
+  };
+}
+
+export function mergeField(
+  field: SchemaField,
+  mergeInto: SchemaField[],
+): SchemaField[] {
+  const existing = mergeInto.find((x) => x.field === field.field);
+  if (existing) {
+    return mergeInto.map((x) =>
+      x !== existing
+        ? x
+        : {
+            ...x,
+            onlyForTypes: mergeTypes(x.onlyForTypes, field.onlyForTypes),
+          },
+    );
+  }
+  return [...mergeInto, field];
+
+  function mergeTypes(f?: string[] | null, s?: string[] | null) {
+    if (!f) return s;
+    if (!s) return f;
+    const extras = s.filter((x) => !f.includes(x));
+    return extras.length ? [...f, ...extras] : f;
+  }
+}
+
+export function mergeFields(
+  fields: SchemaField[],
+  name: string,
+  value: any,
+  newFields: SchemaField[],
+): SchemaField[] {
+  const withType = fields.map((x) =>
+    x.isTypeField ? addFieldOption(x, name, value) : x,
+  );
+  return newFields
+    .map((x) => ({ ...x, onlyForTypes: [value] }))
+    .reduce((af, x) => mergeField(x, af), withType);
+}
+
+export function addFieldOption(
+  typeField: SchemaField,
+  name: string,
+  value: any,
+): SchemaField {
+  const options = typeField.options ?? [];
+  if (options.some((x) => x.value === value)) return typeField;
+  return {
+    ...typeField,
+    options: [...options, { name, value }],
+  };
+}
+
+export function resolveSchemas<A extends SchemaMap>(schemaMap: A): A {
+  const out: SchemaMap = {};
+  function resolveSchemaType(type: string) {
+    if (type in out) {
+      return out[type];
+    }
+    const resolvedFields: SchemaField[] = [];
+    out[type] = resolvedFields;
+    schemaMap[type].forEach((x) => {
+      if (isCompoundField(x) && x.schemaRef) {
+        resolvedFields.push({
+          ...x,
+          children: resolveSchemaType(x.schemaRef),
+        } as CompoundField);
+      } else {
+        resolvedFields.push(x);
+      }
+    });
+    return resolvedFields;
+  }
+  Object.keys(schemaMap).forEach(resolveSchemaType);
+  return out as A;
+}

package/src/schemaDataNode.ts

@@ -0,0 +1,188 @@
+import {
+  Control,
+  ensureMetaValue,
+  newControl,
+  updateComputedValue,
+} from "@astroapps/controls";
+import { missingField } from "./schemaField";
+import { createSchemaNode, resolveSchemaNode, SchemaNode } from "./schemaNode";
+import { SchemaInterface } from "./schemaInterface";
+import { ControlDefinition, getDisplayOnlyOptions } from "./controlDefinition";
+
+export abstract class SchemaDataTree {
+  abstract rootNode: SchemaDataNode;
+
+  abstract getChild(parent: SchemaDataNode, child: SchemaNode): SchemaDataNode;
+
+  abstract getChildElement(
+    parent: SchemaDataNode,
+    elementIndex: number,
+  ): SchemaDataNode;
+}
+
+export class SchemaDataNode {
+  constructor(
+    public id: string,
+    public schema: SchemaNode,
+    public elementIndex: number | undefined,
+    public control: Control<any>,
+    public tree: SchemaDataTree,
+    public parent?: SchemaDataNode,
+  ) {}
+
+  getChild(childNode: SchemaNode): SchemaDataNode {
+    return this.tree.getChild(this, childNode);
+  }
+
+  getChildElement(elementIndex: number): SchemaDataNode {
+    return this.tree.getChildElement(this, elementIndex);
+  }
+}
+
+export function getMetaFields<
+  T extends Record<string, any> = Record<string, unknown>,
+>(control: Control<any>): Control<T> {
+  return ensureMetaValue(
+    control,
+    "metaFields",
+    () => newControl({}) as Control<T>,
+  );
+}
+export class SchemaDataTreeImpl extends SchemaDataTree {
+  rootNode: SchemaDataNode;
+
+  constructor(rootSchema: SchemaNode, rootControl: Control<any>) {
+    super();
+    this.rootNode = new SchemaDataNode(
+      "",
+      rootSchema,
+      undefined,
+      rootControl,
+      this,
+    );
+  }
+
+  getChild(parent: SchemaDataNode, childNode: SchemaNode): SchemaDataNode {
+    let objControl = parent.control as Control<Record<string, unknown>>;
+    if (childNode.field.meta) {
+      objControl = getMetaFields(objControl);
+    }
+    const child = objControl.fields[childNode.field.field];
+    return new SchemaDataNode(
+      child.uniqueId.toString(),
+      childNode,
+      undefined,
+      child,
+      this,
+      parent,
+    );
+  }
+
+  getChildElement(
+    parent: SchemaDataNode,
+    elementIndex: number,
+  ): SchemaDataNode {
+    const elemControl = parent.control as Control<unknown[]>;
+    const elemChild = elemControl.elements[elementIndex];
+    return new SchemaDataNode(
+      elemChild.uniqueId.toString(),
+      parent.schema,
+      elementIndex,
+      elemChild,
+      this,
+      parent,
+    );
+  }
+}
+
+/**
+ * @deprecated Use createSchemaDataNode instead.
+ */
+export const makeSchemaDataNode = createSchemaDataNode;
+
+export function createSchemaDataNode(
+  schema: SchemaNode,
+  control: Control<unknown>,
+): SchemaDataNode {
+  return new SchemaDataTreeImpl(schema, control).rootNode;
+}
+
+export function schemaDataForFieldRef(
+  fieldRef: string | undefined,
+  schema: SchemaDataNode,
+): SchemaDataNode {
+  return schemaDataForFieldPath(fieldRef?.split("/") ?? [], schema);
+}
+
+export function schemaDataForFieldPath(
+  fieldPath: string[],
+  dataNode: SchemaDataNode,
+): SchemaDataNode {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let nextNode =
+      nextField === ".."
+        ? dataNode.parent
+        : nextField === "."
+          ? dataNode
+          : lookupField(nextField);
+    nextNode ??= createSchemaDataNode(
+      createSchemaNode(
+        missingField(nextField),
+        dataNode.schema.tree,
+        dataNode.schema,
+      ),
+      newControl(undefined),
+    );
+    dataNode = nextNode;
+    i++;
+  }
+  return dataNode;
+
+  function lookupField(field: string): SchemaDataNode | undefined {
+    const childNode = resolveSchemaNode(dataNode.schema, field);
+    if (childNode) {
+      return dataNode.getChild(childNode);
+    }
+    return undefined;
+  }
+}
+
+export function validDataNode(context: SchemaDataNode): boolean {
+  const parent = context.parent;
+  if (!parent) return true;
+  if (parent.schema.field.collection && parent.elementIndex == null)
+    return validDataNode(parent);
+  return ensureMetaValue(context.control, "validForSchema", () => {
+    const c = newControl(true);
+    updateComputedValue(c, () => {
+      if (!validDataNode(parent)) return false;
+      const types = context.schema.field.onlyForTypes;
+      if (types == null || types.length === 0) return true;
+      const typeNode = parent.schema
+        .getChildNodes()
+        .find((x) => x.field.isTypeField);
+      if (typeNode == null) {
+        console.warn("No type field found for", parent.schema);
+        return false;
+      }
+      const typeField = parent.getChild(typeNode).control as Control<string>;
+      return typeField && types.includes(typeField.value);
+    });
+    return c;
+  }).value;
+}
+
+export function hideDisplayOnly(
+  context: SchemaDataNode,
+  schemaInterface: SchemaInterface,
+  definition: ControlDefinition,
+) {
+  const displayOptions = getDisplayOnlyOptions(definition);
+  return (
+    displayOptions &&
+    !displayOptions.emptyText &&
+    schemaInterface.isEmptyValue(context.schema.field, context.control?.value)
+  );
+}

package/src/schemaField.ts

@@ -0,0 +1,155 @@
+import { SchemaValidator } from "./schemaValidator";
+
+export type EqualityFunc = (a: any, b: any) => boolean;
+
+/**
+ * Represents a schema field with various properties.
+ */
+export interface SchemaField {
+  /** The type of the field. */
+  type: string;
+  /** The name of the field. */
+  field: string;
+  /** The display name of the field, optional. */
+  displayName?: string | null;
+  /** Tags associated with the field, optional. */
+  tags?: string[] | null;
+  /** Indicates if the field is a system field, optional. */
+  system?: boolean | null;
+  /** Indicates if the field is a meta field, optional. */
+  meta?: boolean | null;
+  /** Indicates if the field is a collection, optional. */
+  collection?: boolean | null;
+  /** Specifies the types for which the field is applicable, optional. */
+  onlyForTypes?: string[] | null;
+  /** Indicates if the field is required, optional. */
+  required?: boolean | null;
+  /** Indicates if the field is not nullable, optional. */
+  notNullable?: boolean | null;
+  /** The default value of the field, optional. */
+  defaultValue?: any;
+  /** Indicates if the field is a type field, optional. */
+  isTypeField?: boolean | null;
+  /** Indicates if the field is searchable, optional. */
+  searchable?: boolean | null;
+  /** Options for the field, optional. */
+  options?: FieldOption[] | null;
+  /** Validators for the field, optional. */
+  validators?: SchemaValidator[] | null;
+}
+
+/**
+ * Represents a map of schema fields.
+ * The key is a string representing the schema name.
+ * The value is an array of SchemaField objects.
+ */
+export type SchemaMap = Record<string, SchemaField[]>;
+
+/**
+ * Enum representing the various field types.
+ */
+export enum FieldType {
+  String = "String",
+  Bool = "Bool",
+  Int = "Int",
+  Date = "Date",
+  DateTime = "DateTime",
+  Time = "Time",
+  Double = "Double",
+  EntityRef = "EntityRef",
+  Compound = "Compound",
+  AutoId = "AutoId",
+  Image = "Image",
+  Any = "Any",
+}
+
+/**
+ * Represents a field that references an entity.
+ */
+export interface EntityRefField extends SchemaField {
+  /** The type of the field, which is EntityRef. */
+  type: FieldType.EntityRef;
+  /** The type of the referenced entity. */
+  entityRefType: string;
+  /** The parent field of the entity reference. */
+  parentField: string;
+}
+
+/**
+ * Represents an option for a field.
+ */
+export interface FieldOption {
+  /** The name of the option. */
+  name: string;
+  /** The value of the option. */
+  value: any;
+  /** The description of the option, optional. */
+  description?: string | null;
+  /** The group of the option, optional. */
+  group?: string | null;
+  /** Indicates if the option is disabled, optional. */
+  disabled?: boolean | null;
+}
+
+/**
+ * Represents a compound field that contains child fields.
+ */
+export interface CompoundField extends SchemaField {
+  /** The type of the field, which is Compound. */
+  type: FieldType.Compound;
+  /** The child fields of the compound field. */
+  children: SchemaField[];
+  /** Indicates if the children are tree-structured, optional. */
+  treeChildren?: boolean;
+  /** The schema reference for the compound field, optional. */
+  schemaRef?: string;
+}
+
+/**
+ * Enum representing the various validation message types.
+ */
+export enum ValidationMessageType {
+  NotEmpty = "NotEmpty",
+  MinLength = "MinLength",
+  MaxLength = "MaxLength",
+  NotAfterDate = "NotAfterDate",
+  NotBeforeDate = "NotBeforeDate",
+}
+
+export function findField(
+  fields: SchemaField[],
+  field: string,
+): SchemaField | undefined {
+  return fields.find((x) => x.field === field);
+}
+
+export function isScalarField(sf: SchemaField): sf is SchemaField {
+  return !isCompoundField(sf);
+}
+
+export function isCompoundField(sf: SchemaField): sf is CompoundField {
+  return sf.type === FieldType.Compound;
+}
+
+export function missingField(field: string): SchemaField {
+  return { field: "__missing", type: FieldType.Any, displayName: field };
+}
+
+export enum SchemaTags {
+  NoControl = "_NoControl",
+  HtmlEditor = "_HtmlEditor",
+  ControlGroup = "_ControlGroup:",
+  ControlRef = "_ControlRef:",
+  IdField = "_IdField:",
+}
+
+export function getTagParam(
+  field: SchemaField,
+  tag: string,
+): string | undefined {
+  return field.tags?.find((x) => x.startsWith(tag))?.substring(tag.length);
+}
+
+export function makeParamTag(tag: string, value: string): string {
+  return `${tag}${value}`;
+}