@astroapps/forms-core 1.2.2 → 2.0.0

package/TODO.txt

@@ -1,3 +1,8 @@
-* Support formData in jsonata
 * nuances with default value
 * Data grid group
+
+
+Test for:
+* jsonata path updating on change of array index
+* Check and radio list tree structure
+* Ensuring calculated visibility doesn't become visible if it were never hidden - vop

package/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+export default {
+  testEnvironment: "node",
+  transform: {
+    "^.+\\.tsx?$": ["ts-jest", { tsconfig: "tsconfig.test.json" }],
+  },
+  preset: "ts-jest",
+};

package/lib/controlBuilder.d.ts

@@ -0,0 +1,60 @@
+import { AccordionAdornment, ActionControlDefinition, AutocompleteRenderOptions, CheckListRenderOptions, ControlAdornmentType, ControlDefinition, DataControlDefinition, DataRenderType, DisplayControlDefinition, DisplayOnlyRenderOptions, DynamicProperty, GroupedControlsDefinition, JsonataRenderOptions, RadioButtonRenderOptions, RenderOptions, TextfieldRenderOptions } from "./controlDefinition";
+import { DateValidator, JsonataValidator, LengthValidator, ValidatorType } from "./schemaValidator";
+import { DataExpression, DataMatchExpression, EntityExpression, ExpressionType, JsonataExpression, NotEmptyExpression } from "./entityExpression";
+export declare function dataControl(field: string, title?: string | null, options?: Partial<DataControlDefinition>): DataControlDefinition;
+export declare function validatorOptions<A extends {
+    type: string;
+}>(type: ValidatorType): (options: Omit<A, "type">) => A;
+export declare function adornmentOptions<A extends {
+    type: string;
+}>(type: ControlAdornmentType): (options: Omit<A, "type">) => A;
+export declare function renderOptionsFor<A extends RenderOptions>(type: DataRenderType): (options: Omit<A, "type">) => {
+    renderOptions: A;
+};
+export declare const autocompleteOptions: (options: Omit<AutocompleteRenderOptions, "type">) => {
+    renderOptions: AutocompleteRenderOptions;
+};
+export declare const checkListOptions: (options: Omit<CheckListRenderOptions, "type">) => {
+    renderOptions: CheckListRenderOptions;
+};
+export declare const radioButtonOptions: (options: Omit<RadioButtonRenderOptions, "type">) => {
+    renderOptions: RadioButtonRenderOptions;
+};
+export declare const lengthValidatorOptions: (options: Omit<LengthValidator, "type">) => LengthValidator;
+export declare const jsonataValidatorOptions: (options: Omit<JsonataValidator, "type">) => JsonataValidator;
+export declare const dateValidatorOptions: (options: Omit<DateValidator, "type">) => DateValidator;
+export declare const accordionOptions: (options: Omit<AccordionAdornment, "type">) => AccordionAdornment;
+export declare const textfieldOptions: (options: Omit<TextfieldRenderOptions, "type">) => {
+    renderOptions: TextfieldRenderOptions;
+};
+export declare const displayOnlyOptions: (options: Omit<DisplayOnlyRenderOptions, "type">) => {
+    renderOptions: DisplayOnlyRenderOptions;
+};
+export declare const jsonataOptions: (options: Omit<JsonataRenderOptions, "type">) => {
+    renderOptions: JsonataRenderOptions;
+};
+export declare function textDisplayControl(text: string, options?: Partial<DisplayControlDefinition>): DisplayControlDefinition;
+export declare function htmlDisplayControl(html: string, options?: Partial<DisplayControlDefinition>): DisplayControlDefinition;
+export declare function dynamicDefaultValue(expr: EntityExpression): DynamicProperty;
+export declare function dynamicReadonly(expr: EntityExpression): DynamicProperty;
+export declare function dynamicVisibility(expr: EntityExpression): DynamicProperty;
+export declare function dynamicDisabled(expr: EntityExpression): DynamicProperty;
+export declare function dataExpr(field: string): DataExpression;
+/**
+ * @deprecated Use dataExpr
+ */
+export declare const fieldExpr: typeof dataExpr;
+/**
+ * @deprecated Use dataMatchExpr
+ */
+export declare const fieldEqExpr: typeof dataMatchExpr;
+export declare const uuidExpr: {
+    type: ExpressionType;
+};
+export declare function dataMatchExpr(field: string, value: any): DataMatchExpression;
+export declare function notEmptyExpr(field: string, empty?: boolean): NotEmptyExpression;
+export declare function jsonataExpr(expression: string): JsonataExpression;
+export declare function groupedControl(children: ControlDefinition[], title?: string, options?: Partial<GroupedControlsDefinition>): GroupedControlsDefinition;
+export declare function compoundControl(field: string, title: string | undefined | null, children: ControlDefinition[], options?: Partial<DataControlDefinition>): DataControlDefinition;
+export declare function actionControl(actionText: string, actionId: string, options?: Partial<ActionControlDefinition>): ActionControlDefinition;
+export declare const emptyGroupDefinition: GroupedControlsDefinition;

package/lib/controlDefinition.d.ts

@@ -16,6 +16,8 @@ export interface ControlDefinition {
     childRefId?: string | null;
     title?: string | null;
     hidden?: boolean | null;
+    disabled?: boolean | null;
+    readonly?: boolean | null;
     styleClass?: string | null;
     textClass?: string | null;
     layoutClass?: string | null;
@@ -46,7 +48,8 @@ export declare enum DynamicPropertyType {
     LayoutStyle = "LayoutStyle",
     AllowedOptions = "AllowedOptions",
     Label = "Label",
-    ActionData = "ActionData"
+    ActionData = "ActionData",
+    GridColumns = "GridColumns"
 }
 export interface ControlAdornment {
     type: string;
@@ -112,11 +115,10 @@ export interface DataControlDefinition extends ControlDefinition {
     required?: boolean | null;
     renderOptions?: RenderOptions | null;
     defaultValue?: any;
-    readonly?: boolean | null;
-    disabled?: boolean | null;
     validators?: SchemaValidator[] | null;
     hideTitle?: boolean | null;
     dontClearHidden?: boolean | null;
+    requiredErrorText?: string | null;
 }
 export interface RenderOptions {
     type: string;
@@ -141,7 +143,8 @@ export declare enum DataRenderType {
     Jsonata = "Jsonata",
     Array = "Array",
     ArrayElement = "ArrayElement",
-    ElementSelected = "ElementSelected"
+    ElementSelected = "ElementSelected",
+    ScrollList = "ScrollList"
 }
 export interface TextfieldRenderOptions extends RenderOptions {
     type: DataRenderType.Textfield;
@@ -216,6 +219,7 @@ export interface ArrayRenderOptions extends RenderOptions {
     noRemove?: boolean | null;
     noReorder?: boolean | null;
     editExternal?: boolean | null;
+    childOverrideClass?: string | null;
 }
 export interface ArrayElementRenderOptions extends RenderOptions {
     type: DataRenderType.ArrayElement;
@@ -251,6 +255,11 @@ export interface UserSelectionRenderOptions extends RenderOptions {
 export interface IconSelectionRenderOptions extends RenderOptions {
     type: DataRenderType.IconSelector;
 }
+export interface ScrollListRenderOptions extends RenderOptions {
+    type: DataRenderType.ScrollList;
+    bottomActionId?: string;
+    refreshActionId?: string;
+}
 export interface GroupedControlsDefinition extends ControlDefinition {
     type: ControlDefinitionType.Group;
     compoundField?: string | null;
@@ -282,11 +291,18 @@ export declare enum GroupRenderType {
     Inline = "Inline",
     Wizard = "Wizard",
     Dialog = "Dialog",
-    Contents = "Contents"
+    Contents = "Contents",
+    Accordion = "Accordion"
+}
+export interface AccordionRenderer extends GroupRenderOptions {
+    type: GroupRenderType.Accordion;
+    defaultExpanded?: boolean | null;
+    expandStateField?: string | null;
 }
 export interface DialogRenderOptions extends GroupRenderOptions {
     type: GroupRenderType.Dialog;
     title?: string | null;
+    portalHost?: string | null;
 }
 export interface StandardGroupRenderer extends GroupRenderOptions {
     type: GroupRenderType.Standard;
@@ -300,10 +316,11 @@ export interface GroupElementRenderer extends GroupRenderOptions {
     type: GroupRenderType.GroupElement;
     value: any;
 }
-export interface GridRenderer extends GroupRenderOptions {
+export interface GridRendererOptions extends GroupRenderOptions {
     type: GroupRenderType.Grid;
     columns?: number | null;
     rowClass?: string | null;
+    cellClass?: string | null;
 }
 export interface TabsRenderOptions extends GroupRenderOptions {
     type: GroupRenderType.Tabs;
@@ -346,6 +363,11 @@ export interface CustomDisplay extends DisplayData {
     type: DisplayDataType.Custom;
     customId: string;
 }
+export declare enum ControlDisableType {
+    None = "None",
+    Self = "Self",
+    Global = "Global"
+}
 export interface ActionControlDefinition extends ControlDefinition {
     type: ControlDefinitionType.Action;
     actionId: string;
@@ -353,6 +375,7 @@ export interface ActionControlDefinition extends ControlDefinition {
     icon?: IconReference | null;
     actionStyle?: ActionStyle | null;
     iconPlacement?: IconPlacement | null;
+    disableType?: ControlDisableType | null;
 }
 export declare enum ActionStyle {
     Button = "Button",
@@ -372,10 +395,11 @@ export interface ControlVisitor<A> {
     action(d: ActionControlDefinition): A;
 }
 export declare function visitControlDefinition<A>(x: ControlDefinition, visitor: ControlVisitor<A>, defaultValue: (c: ControlDefinition) => A): A;
-export declare function isGridRenderer(options: GroupRenderOptions): options is GridRenderer;
+export declare function isGridRenderer(options: GroupRenderOptions): options is GridRendererOptions;
 export declare function isWizardRenderer(options: GroupRenderOptions): options is WizardRenderOptions;
 export declare function isDialogRenderer(options: GroupRenderOptions): options is DialogRenderOptions;
-export declare function isInlineRenderer(options: GroupRenderOptions): options is GridRenderer;
+export declare function isAccordionRenderer(options: GroupRenderOptions): options is AccordionRenderer;
+export declare function isInlineRenderer(options: GroupRenderOptions): boolean;
 export declare function isSelectChildRenderer(options: GroupRenderOptions): options is SelectChildRenderer;
 export declare function isTabsRenderer(options: GroupRenderOptions): options is TabsRenderOptions;
 export declare function isFlexRenderer(options: GroupRenderOptions): options is FlexRenderer;

package/lib/evalExpression.d.ts

@@ -1,5 +1,5 @@
 import { EntityExpression, JsonataExpression } from "./entityExpression";
-import { CleanupScope, Value } from "@astroapps/controls";
+import { ChangeListenerFunc, CleanupScope, Control } from "@astroapps/controls";
 import { SchemaDataNode } from "./schemaDataNode";
 import { SchemaInterface } from "./schemaInterface";
 export interface ExpressionEvalContext {
@@ -7,10 +7,11 @@ export interface ExpressionEvalContext {
     returnResult: (k: unknown) => void;
     dataNode: SchemaDataNode;
     schemaInterface: SchemaInterface;
-    variables?: Value<Record<string, any> | undefined>;
+    variables?: (changes: ChangeListenerFunc<any>) => Record<string, any>;
     runAsync(effect: () => void): void;
 }
 export type ExpressionEval<T extends EntityExpression> = (expr: T, context: ExpressionEvalContext) => void;
 export declare const jsonataEval: ExpressionEval<JsonataExpression>;
 export declare const uuidEval: ExpressionEval<EntityExpression>;
 export declare const defaultEvaluators: Record<string, ExpressionEval<any>>;
+export declare function createEvalExpr(evalExpression: (e: EntityExpression, ctx: ExpressionEvalContext) => void, context: Omit<ExpressionEvalContext, "returnResult" | "scope">): <A>(scope: CleanupScope, init: A, nk: Control<A>, e: EntityExpression | undefined, coerce: (t: unknown) => any) => boolean;

package/lib/formNode.d.ts

@@ -43,10 +43,3 @@ export declare function visitControlData<A>(definition: ControlDefinition, ctx:
 export type ControlDataVisitor<A> = (dataNode: SchemaDataNode, definition: DataControlDefinition) => A | undefined;
 export declare function visitFormData<A>(node: FormNode, dataNode: SchemaDataNode, cb: ControlDataVisitor<A>, notSelf?: boolean): A | undefined;
 export declare function visitFormDataInContext<A>(parentContext: SchemaDataNode, node: FormNode, cb: ControlDataVisitor<A>): A | undefined;
-export interface FormDataNode {
-    parent?: FormDataNode;
-    formNode: FormNode;
-    parentData: SchemaDataNode;
-    childIndex?: number;
-}
-export declare function visitFormDataNode<A>(node: FormDataNode, visitFn: (node: FormDataNode, data?: SchemaDataNode) => A | undefined): A | undefined;

package/lib/formStateNode.d.ts

@@ -0,0 +1,134 @@
+import { FormNode } from "./formNode";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaInterface } from "./schemaInterface";
+import { FieldOption } from "./schemaField";
+import { ChangeListenerFunc, CleanupScope, Control } from "@astroapps/controls";
+import { ExpressionEvalContext } from "./evalExpression";
+import { EntityExpression } from "./entityExpression";
+import { ControlDefinition, ControlDisableType } from "./controlDefinition";
+import { ChildNodeSpec, ChildResolverFunc } from "./resolveChildren";
+export type EvalExpr = <A>(scope: CleanupScope, init: A, nk: Control<A>, e: EntityExpression | undefined, coerce: (t: unknown) => any) => boolean;
+export type VariablesFunc = (changes: ChangeListenerFunc<any>) => Record<string, any>;
+export interface FormNodeOptions {
+    forceReadonly?: boolean;
+    forceDisabled?: boolean;
+    forceHidden?: boolean;
+    variables?: VariablesFunc;
+}
+export interface FormGlobalOptions {
+    schemaInterface: SchemaInterface;
+    evalExpression: (e: EntityExpression, ctx: ExpressionEvalContext) => void;
+    resolveChildren(c: FormStateNode): ChildNodeSpec[];
+    runAsync: (af: () => void) => void;
+    clearHidden: boolean;
+}
+export interface ResolvedDefinition {
+    definition: ControlDefinition;
+    display?: string;
+    stateId?: string;
+    style?: object;
+    layoutStyle?: object;
+    fieldOptions?: FieldOption[];
+}
+export interface FormStateBase {
+    parent: SchemaDataNode;
+    dataNode?: SchemaDataNode | undefined;
+    readonly: boolean;
+    visible: boolean | null;
+    disabled: boolean;
+    resolved: ResolvedDefinition;
+    childIndex: number;
+    busy: boolean;
+}
+export interface FormNodeUi {
+    ensureVisible(): void;
+    ensureChildVisible(childIndex: number): void;
+    getDisabler(type: ControlDisableType): () => () => void;
+}
+export interface FormStateNode extends FormStateBase, FormNodeOptions {
+    childKey: string | number;
+    uniqueId: string;
+    definition: ControlDefinition;
+    schemaInterface: SchemaInterface;
+    valid: boolean;
+    touched: boolean;
+    clearHidden: boolean;
+    variables?: (changes: ChangeListenerFunc<any>) => Record<string, any>;
+    meta: Record<string, any>;
+    form: FormNode | undefined | null;
+    children: FormStateNode[];
+    parentNode: FormStateNode | undefined;
+    setTouched(b: boolean, notChildren?: boolean): void;
+    validate(): boolean;
+    getChildCount(): number;
+    getChild(index: number): FormStateNode | undefined;
+    ensureMeta<A>(key: string, init: (scope: CleanupScope) => A): A;
+    cleanup(): void;
+    ui: FormNodeUi;
+    attachUi(f: FormNodeUi): void;
+    setBusy(busy: boolean): void;
+    setForceDisabled(forceDisable: boolean): void;
+}
+export declare function createEvaluatedDefinition(def: ControlDefinition, evalExpr: EvalExpr, scope: CleanupScope, display: Control<string | undefined>): ControlDefinition;
+export declare function coerceStyle(v: unknown): any;
+export declare function coerceString(v: unknown): string;
+export declare function createFormStateNode(formNode: FormNode, parent: SchemaDataNode, options: FormGlobalOptions, nodeOptions: FormNodeOptions): FormStateNodeImpl;
+export interface FormStateBaseImpl extends FormStateBase {
+    children: FormStateBaseImpl[];
+    allowedOptions?: unknown;
+    nodeOptions: FormNodeOptions;
+    busy: boolean;
+}
+export declare const noopUi: FormNodeUi;
+declare class FormStateNodeImpl implements FormStateNode {
+    childKey: string | number;
+    meta: Record<string, any>;
+    form: FormNode | undefined | null;
+    readonly globals: Control<FormGlobalOptions>;
+    parent: SchemaDataNode;
+    parentNode: FormStateNode | undefined;
+    readonly base: Control<FormStateBaseImpl>;
+    readonly options: Control<FormNodeOptions>;
+    readonly resolveChildren: ChildResolverFunc;
+    ui: FormNodeUi;
+    constructor(childKey: string | number, meta: Record<string, any>, definition: ControlDefinition, form: FormNode | undefined | null, nodeOptions: FormNodeOptions, globals: Control<FormGlobalOptions>, parent: SchemaDataNode, parentNode: FormStateNode | undefined, childIndex: number, resolveChildren?: ChildResolverFunc);
+    get busy(): boolean;
+    setBusy(busy: boolean): void;
+    get evalExpression(): (e: EntityExpression, ctx: ExpressionEvalContext) => void;
+    get runAsync(): (af: () => void) => void;
+    get schemaInterface(): SchemaInterface;
+    get forceDisabled(): boolean | undefined;
+    setForceDisabled(value: boolean): boolean;
+    get forceReadonly(): boolean | undefined;
+    get forceHidden(): boolean | undefined;
+    attachUi(f: FormNodeUi): void;
+    get childIndex(): number;
+    get children(): FormStateNode[];
+    get uniqueId(): string;
+    get valid(): boolean;
+    get touched(): boolean;
+    setTouched(touched: boolean, notChildren?: boolean): void;
+    validate(): boolean;
+    get readonly(): boolean;
+    get visible(): boolean | null;
+    get disabled(): boolean;
+    get clearHidden(): boolean;
+    get variables(): VariablesFunc | undefined;
+    get definition(): ControlDefinition;
+    getChild(index: number): FormStateNode;
+    getChildCount(): number;
+    cleanup(): void;
+    get resolved(): ResolvedDefinition;
+    get dataNode(): SchemaDataNode | undefined;
+    ensureMeta<A>(key: string, init: (scope: CleanupScope) => A): A;
+}
+export declare function combineVariables(v1?: VariablesFunc, v2?: VariablesFunc): VariablesFunc | undefined;
+/**
+ * Interface representing the form context data.
+ */
+export interface FormContextData {
+    option?: FieldOption;
+    optionSelected?: boolean;
+}
+export declare function visitFormState<A>(node: FormStateNode, visitFn: (node: FormStateNode) => A | undefined): A | undefined;
+export {};