@researchdatabox/sails-ng-common 0.0.1-beta.8936

package/dist/src/config/form-behaviour.outline.d.ts

@@ -0,0 +1,128 @@
+import { ExpressionsConditionKindType } from './form-component.outline';
+/**
+ * Form behaviours are the v1 form-level automation primitive described in
+ * `support/specs/form-behaviour/implementation_plan.md`.
+ *
+ * Intent:
+ * - allow async, event-driven pipelines at the form level instead of only
+ *   component-scoped synchronous expressions
+ * - keep the configuration serialisable so it can pass through the existing
+ *   Construct -> Template -> Client visitor pipeline
+ *
+ * Scope in v1:
+ * - built-in processors only: `jsonataTransform`, `fetchMetadata`
+ * - built-in actions only: `setValue`, `emitEvent`
+ * - event emission is intentionally limited to `field.value.changed`
+ *
+ * Out of scope in v1:
+ * - hook-registered/custom processors and actions
+ * - UI-specific actions such as notifications or highlighting
+ * - processor-level debounce controls
+ *
+ * These types are intentionally lightweight outlines rather than runtime
+ * classes because the behaviour feature currently relies on plain config data.
+ */
+export declare const FormBehaviourProcessorType: {
+    readonly JSONataTransform: "jsonataTransform";
+    readonly FetchMetadata: "fetchMetadata";
+};
+export type FormBehaviourProcessorTypeValue = (typeof FormBehaviourProcessorType)[keyof typeof FormBehaviourProcessorType];
+export declare const FormBehaviourActionType: {
+    readonly SetValue: "setValue";
+    readonly EmitEvent: "emitEvent";
+};
+export type FormBehaviourActionTypeValue = (typeof FormBehaviourActionType)[keyof typeof FormBehaviourActionType];
+export declare const FieldPathKind: {
+    readonly ComponentJsonPointer: "componentJsonPointer";
+    readonly JSONata: "jsonata";
+    readonly Logical: "logical";
+};
+export type FieldPathKindType = (typeof FieldPathKind)[keyof typeof FieldPathKind];
+/**
+ * Configuration for the v1 JSONata processor.
+ *
+ * The server keeps `template` long enough to compile it, while the client uses
+ * `hasTemplate` after the raw source has been stripped by the client visitor.
+ */
+export interface FormBehaviourJsonataTransformConfig {
+    template?: string;
+    hasTemplate?: boolean;
+}
+export interface FormBehaviourProcessorConfigFrame<TConfig = Record<string, never> | FormBehaviourJsonataTransformConfig> {
+    type: FormBehaviourProcessorTypeValue;
+    config?: TConfig;
+}
+export type FormBehaviourJsonataTransformProcessorConfig = FormBehaviourProcessorConfigFrame<FormBehaviourJsonataTransformConfig> & {
+    type: typeof FormBehaviourProcessorType.JSONataTransform;
+};
+export type FormBehaviourFetchMetadataProcessorConfig = FormBehaviourProcessorConfigFrame<Record<string, never>> & {
+    type: typeof FormBehaviourProcessorType.FetchMetadata;
+};
+export type FormBehaviourProcessorConfig = FormBehaviourJsonataTransformProcessorConfig | FormBehaviourFetchMetadataProcessorConfig;
+/**
+ * `fieldPath` points at an `angularComponentsJsonPointer`.
+ *
+ * Resolution modes intentionally mirror the implementation plan:
+ * - `componentJsonPointer`: literal pointer resolved at execution time
+ * - `jsonata`: compiled template resolved against the current pipeline context
+ * - `logical`: repeatable-only identity lock that survives row reindexing
+ *
+ * Note that `logical` is validated by the runtime and is intentionally not
+ * allowed on `onError` actions in v1.
+ */
+export interface FormBehaviourSetValueActionConfig {
+    fieldPath: string;
+    fieldPathKind?: FieldPathKindType;
+    hasFieldPathTemplate?: boolean;
+    valueTemplate?: string;
+    hasValueTemplate?: boolean;
+}
+/**
+ * v1 keeps emitted events deliberately narrow to avoid inventing another event
+ * contract before behaviour usage patterns settle.
+ */
+export interface FormBehaviourEmitEventActionConfig {
+    eventType: 'field.value.changed';
+    fieldId: string;
+    sourceId: string;
+    valueTemplate?: string;
+    hasValueTemplate?: boolean;
+}
+export interface FormBehaviourActionConfigFrame<TConfig = FormBehaviourSetValueActionConfig | FormBehaviourEmitEventActionConfig> {
+    type: FormBehaviourActionTypeValue;
+    config: TConfig;
+}
+export type FormBehaviourSetValueAction = FormBehaviourActionConfigFrame<FormBehaviourSetValueActionConfig> & {
+    type: typeof FormBehaviourActionType.SetValue;
+};
+export type FormBehaviourEmitEventAction = FormBehaviourActionConfigFrame<FormBehaviourEmitEventActionConfig> & {
+    type: typeof FormBehaviourActionType.EmitEvent;
+};
+export type FormBehaviourActionConfig = FormBehaviourSetValueAction | FormBehaviourEmitEventAction;
+/**
+ * Top-level behaviour definition stored on `FormConfigFrame.behaviours`.
+ *
+ * Design notes:
+ * - `condition` / `conditionKind` intentionally reuse expression semantics
+ * - `debounceMs` applies at subscription level, not per processor
+ * - `hasCondition` is a client-side marker added after template stripping
+ * - `enabled` exists so a behaviour can remain in config without binding
+ *
+ * Future work anticipated by the plan:
+ * - more processors/actions
+ * - hook extensibility
+ * - richer UI-facing actions
+ */
+export interface FormBehaviourConfigFrame {
+    name: string;
+    description?: string;
+    condition: string;
+    conditionKind?: ExpressionsConditionKindType;
+    debounceMs?: number;
+    processors?: FormBehaviourProcessorConfig[];
+    actions: FormBehaviourActionConfig[];
+    onError?: FormBehaviourActionConfig[];
+    runOnFormReady?: boolean;
+    enabled?: boolean;
+    hasCondition?: boolean;
+}

package/dist/src/config/form-behaviour.outline.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldPathKind = exports.FormBehaviourActionType = exports.FormBehaviourProcessorType = void 0;
+/**
+ * Form behaviours are the v1 form-level automation primitive described in
+ * `support/specs/form-behaviour/implementation_plan.md`.
+ *
+ * Intent:
+ * - allow async, event-driven pipelines at the form level instead of only
+ *   component-scoped synchronous expressions
+ * - keep the configuration serialisable so it can pass through the existing
+ *   Construct -> Template -> Client visitor pipeline
+ *
+ * Scope in v1:
+ * - built-in processors only: `jsonataTransform`, `fetchMetadata`
+ * - built-in actions only: `setValue`, `emitEvent`
+ * - event emission is intentionally limited to `field.value.changed`
+ *
+ * Out of scope in v1:
+ * - hook-registered/custom processors and actions
+ * - UI-specific actions such as notifications or highlighting
+ * - processor-level debounce controls
+ *
+ * These types are intentionally lightweight outlines rather than runtime
+ * classes because the behaviour feature currently relies on plain config data.
+ */
+exports.FormBehaviourProcessorType = {
+    JSONataTransform: 'jsonataTransform',
+    FetchMetadata: 'fetchMetadata',
+};
+exports.FormBehaviourActionType = {
+    SetValue: 'setValue',
+    EmitEvent: 'emitEvent',
+};
+exports.FieldPathKind = {
+    ComponentJsonPointer: 'componentJsonPointer',
+    JSONata: 'jsonata',
+    Logical: 'logical',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1iZWhhdmlvdXIub3V0bGluZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZm9ybS1iZWhhdmlvdXIub3V0bGluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUNVLFFBQUEsMEJBQTBCLEdBQUc7SUFDeEMsZ0JBQWdCLEVBQUUsa0JBQWtCO0lBQ3BDLGFBQWEsRUFBRSxlQUFlO0NBQ3RCLENBQUM7QUFLRSxRQUFBLHVCQUF1QixHQUFHO0lBQ3JDLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLFNBQVMsRUFBRSxXQUFXO0NBQ2QsQ0FBQztBQUlFLFFBQUEsYUFBYSxHQUFHO0lBQzNCLG9CQUFvQixFQUFFLHNCQUFzQjtJQUM1QyxPQUFPLEVBQUUsU0FBUztJQUNsQixPQUFPLEVBQUUsU0FBUztDQUNWLENBQUMifQ==

package/dist/src/config/form-component.model.d.ts

@@ -0,0 +1,38 @@
+import { FormConfigVisitorOutline } from "./visitor/base.outline";
+import { FormComponentDefinitionOutline, FormConstraintAuthorizationConfigOutline, FormConstraintConfigOutline, FormExpressionsConfigOutline, FormOverrideConfigFrame } from "./form-component.outline";
+import { FieldComponentDefinitionOutline } from "./field-component.outline";
+import { FieldModelDefinitionOutline } from "./field-model.outline";
+import { FieldLayoutDefinitionOutline } from "./field-layout.outline";
+import { FormModesConfig } from "./shared.outline";
+export declare class FormExpressionsConfig implements FormExpressionsConfigOutline {
+    name: string;
+    description?: string;
+    config: FormExpressionsConfigOutline['config'];
+}
+/**
+ * The constraints that must be fulfilled for the form field to be included.
+ */
+export declare class FormConstraintConfig implements FormConstraintConfigOutline {
+    authorization?: FormConstraintAuthorizationConfig;
+    allowModes?: FormModesConfig[];
+}
+/**
+ * The options available for the authorization constraints.
+ */
+export declare class FormConstraintAuthorizationConfig implements FormConstraintAuthorizationConfigOutline {
+    allowRoles?: string[];
+}
+/**
+ * The form component abstract class is the base for each real component definition class.
+ */
+export declare abstract class FormComponentDefinition implements FormComponentDefinitionOutline {
+    name: string;
+    abstract component: FieldComponentDefinitionOutline;
+    abstract model?: FieldModelDefinitionOutline<unknown>;
+    abstract layout?: FieldLayoutDefinitionOutline;
+    expressions?: FormExpressionsConfigOutline[];
+    module?: string;
+    constraints?: FormConstraintConfigOutline;
+    overrides?: FormOverrideConfigFrame;
+    abstract accept(visitor: FormConfigVisitorOutline): void;
+}

package/dist/src/config/form-component.model.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormComponentDefinition = exports.FormConstraintAuthorizationConfig = exports.FormConstraintConfig = exports.FormExpressionsConfig = void 0;
+class FormExpressionsConfig {
+    name = '';
+    description;
+    config = { template: '' };
+}
+exports.FormExpressionsConfig = FormExpressionsConfig;
+/**
+ * The constraints that must be fulfilled for the form field to be included.
+ */
+class FormConstraintConfig {
+    authorization;
+    allowModes;
+}
+exports.FormConstraintConfig = FormConstraintConfig;
+/**
+ * The options available for the authorization constraints.
+ */
+class FormConstraintAuthorizationConfig {
+    allowRoles;
+}
+exports.FormConstraintAuthorizationConfig = FormConstraintAuthorizationConfig;
+/**
+ * The form component abstract class is the base for each real component definition class.
+ */
+class FormComponentDefinition {
+    name = "";
+    expressions;
+    module;
+    constraints;
+    overrides;
+}
+exports.FormComponentDefinition = FormComponentDefinition;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1jb21wb25lbnQubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29uZmlnL2Zvcm0tY29tcG9uZW50Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVlBLE1BQWEscUJBQXFCO0lBQzlCLElBQUksR0FBVyxFQUFFLENBQUM7SUFDbEIsV0FBVyxDQUFVO0lBQ3JCLE1BQU0sR0FBMkMsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUM7Q0FDckU7QUFKRCxzREFJQztBQUVEOztHQUVHO0FBQ0gsTUFBYSxvQkFBb0I7SUFDN0IsYUFBYSxDQUFxQztJQUNsRCxVQUFVLENBQW9CO0NBQ2pDO0FBSEQsb0RBR0M7QUFFRDs7R0FFRztBQUNILE1BQWEsaUNBQWlDO0lBQzFDLFVBQVUsQ0FBWTtDQUN6QjtBQUZELDhFQUVDO0FBR0Q7O0dBRUc7QUFDSCxNQUFzQix1QkFBdUI7SUFDbEMsSUFBSSxHQUFXLEVBQUUsQ0FBQztJQUlsQixXQUFXLENBQWtDO0lBQzdDLE1BQU0sQ0FBVTtJQUNoQixXQUFXLENBQStCO0lBQzFDLFNBQVMsQ0FBMkI7Q0FHOUM7QUFYRCwwREFXQyJ9

package/dist/src/config/form-component.outline.d.ts

@@ -0,0 +1,257 @@
+import { CanVisit } from "./visitor/base.outline";
+import { FieldModelDefinitionFrame, FieldModelDefinitionOutline } from "./field-model.outline";
+import { FieldComponentDefinitionFrame, FieldComponentDefinitionOutline } from "./field-component.outline";
+import { FormModesConfig } from "./shared.outline";
+import { FieldLayoutDefinitionFrame, FieldLayoutDefinitionOutline } from "./field-layout.outline";
+import { ComponentClassNamesType, LayoutClassNamesType, ModelClassNamesType } from "./dictionary.model";
+/**
+ * The kinds of conditions available for expressions.
+ *
+ * JSONPointer - Uses JSON Pointer syntax to point to a value in the form data. For wiring events between fields, this is often sufficient. This is simple and fast to evaluate.
+ *
+ * JSONata - Uses the JSONata query and transformation language to evaluate more complex conditions based on data supplied at evaluation time. Template must resolve to a truthy value. This is more powerful but may be slower to evaluate.
+ *
+ * JSONataQuery - Similar to JSONata, but uses the FormComponent.componentDefQuerySource in addition to those supplied at evaluation time. This is useful for conditions that depend on multiple fields or the structure of the form itself.
+ *
+ * @see FormExpressionsConfigFrame.conditionKind
+ */
+export declare const ExpressionsConditionKind: {
+    readonly JSONPointer: "jsonpointer";
+    readonly JSONata: "jsonata";
+    readonly JSONataQuery: "jsonata_query";
+};
+export type ExpressionsConditionKindType = typeof ExpressionsConditionKind[keyof typeof ExpressionsConditionKind];
+/**
+ * The shared properties for an expression config.
+ *
+ * Notes:
+ * - 'target': Optional property name that will receive the result of the expression.
+ *   If unspecified, the result is not stored. Note that the template or operation might set values directly.
+ * - 'operation' and 'template': Must specify one of these.
+ */
+interface FormExpressionsBaseConfigFrame {
+    /**
+     * The JSONata template or customised JSONPointer string that resolves to a boolean indicating whether to execute the expression. If unspecified, the expression always executes.
+     */
+    condition?: string;
+    /**
+     * The kind of condition to use.
+     */
+    conditionKind?: ExpressionsConditionKindType;
+    /**
+     * Indicates whether the expression has a template defined. Set when template is stripped prior to sending to client.
+     */
+    hasTemplate?: boolean;
+    /**
+     * Optional flag to indicate whether the expression will run when the form is ready. Defaults to true.
+     */
+    runOnFormReady?: boolean;
+}
+/**
+ * An expression that requires the operation.
+ */
+interface FormExpressionsOperationConfigFrame {
+    /**
+     * The name of the entry in the `operations` dictionary to execute.
+     * Must be provided.
+     */
+    operation: string;
+    /**
+     * The JSONata template for the expression. This only is populated in the server-side, the client side will retrieve the template from the pre-compiled dictionary.
+     * Optional when operation is provided.
+     */
+    template?: string;
+}
+/**
+ * An expression that requires the template.
+ */
+interface FormExpressionsTemplateConfigFrame {
+    /**
+     * The JSONata template for the expression. This only is populated in the server-side, the client side will retrieve the template from the pre-compiled dictionary.
+     * Must be provided.
+     */
+    template: string;
+    /**
+     * The name of the entry in the `operations` dictionary to execute.
+     * Optional when template is provided.
+     */
+    operation?: string;
+}
+export declare const FormExpressionsTargetModelValue: "model.value";
+type FormExpressionsTargetModelValueType = typeof FormExpressionsTargetModelValue;
+interface FormExpressionsTargetModelValueConfigFrame {
+    /**
+     * The component's model value will receive the result of the expression.
+     */
+    target: FormExpressionsTargetModelValueType;
+}
+export declare const FormExpressionsTargetLayoutPrefix: "layout.";
+interface FormExpressionsTargetLayoutConfigFrame {
+    /**
+     * Layout property name that will receive the result of the expression.
+     */
+    target: `layout.${string}`;
+}
+export declare const FormExpressionsTargetComponentPrefix: "component.";
+interface FormExpressionsTargetComponentConfigFrame {
+    /**
+     * Component property name that will receive the result of the expression.
+     */
+    target: `component.${string}`;
+}
+export declare const FormExpressionsTargetValidationGroups: "form.enabledValidationGroups";
+type FormExpressionsTargetValidationGroupsType = typeof FormExpressionsTargetValidationGroups;
+interface FormExpressionsTargetValidationGroupsConfigFrame {
+    /**
+     * Create an event to change the enabled validation groups to be as the result of the expression specifies.
+     */
+    target: FormExpressionsTargetValidationGroupsType;
+}
+export interface FormExpressionsOperationNoTargetConfigFrame extends FormExpressionsBaseConfigFrame, FormExpressionsOperationConfigFrame {
+}
+export interface FormExpressionsTemplateNoTargetConfigFrame extends FormExpressionsBaseConfigFrame, FormExpressionsTemplateConfigFrame {
+}
+export interface FormExpressionsOperationModelValueConfigFrame extends FormExpressionsOperationNoTargetConfigFrame, FormExpressionsTargetModelValueConfigFrame {
+}
+export interface FormExpressionsTemplateModelValueConfigFrame extends FormExpressionsTemplateNoTargetConfigFrame, FormExpressionsTargetModelValueConfigFrame {
+}
+export interface FormExpressionsOperationLayoutConfigFrame extends FormExpressionsOperationNoTargetConfigFrame, FormExpressionsTargetLayoutConfigFrame {
+}
+export interface FormExpressionsTemplateLayoutConfigFrame extends FormExpressionsTemplateNoTargetConfigFrame, FormExpressionsTargetLayoutConfigFrame {
+}
+export interface FormExpressionsOperationComponentConfigFrame extends FormExpressionsOperationNoTargetConfigFrame, FormExpressionsTargetComponentConfigFrame {
+}
+export interface FormExpressionsTemplateComponentConfigFrame extends FormExpressionsTemplateNoTargetConfigFrame, FormExpressionsTargetComponentConfigFrame {
+}
+export interface FormExpressionsOperationValidationGroupsConfigFrame extends FormExpressionsOperationNoTargetConfigFrame, FormExpressionsTargetValidationGroupsConfigFrame {
+}
+export interface FormExpressionsTemplateValidationGroupsConfigFrame extends FormExpressionsTemplateNoTargetConfigFrame, FormExpressionsTargetValidationGroupsConfigFrame {
+}
+/**
+ * The available form expression configuration structures.
+ */
+export type FormExpressionsOptionsConfigFrame = FormExpressionsOperationNoTargetConfigFrame | FormExpressionsTemplateNoTargetConfigFrame | FormExpressionsOperationModelValueConfigFrame | FormExpressionsTemplateModelValueConfigFrame | FormExpressionsOperationLayoutConfigFrame | FormExpressionsTemplateLayoutConfigFrame | FormExpressionsOperationComponentConfigFrame | FormExpressionsTemplateComponentConfigFrame | FormExpressionsOperationValidationGroupsConfigFrame | FormExpressionsTemplateValidationGroupsConfigFrame;
+/**
+ * The expressions for a component.
+ */
+export interface FormExpressionsConfigFrame {
+    /**
+     * The unique short name of the expression.
+     */
+    name: string;
+    /**
+     * A description of the expression.
+     */
+    description?: string;
+    /**
+     * The configuration for the expression.
+     */
+    config: FormExpressionsOptionsConfigFrame;
+}
+export interface FormExpressionsConfigOutline extends FormExpressionsConfigFrame {
+}
+export interface FormConstraintConfigFrame {
+    /**
+     * The current user must fulfill these authorization constraints.
+     * This is only available on the server side.
+     * These are checked first.
+     */
+    authorization?: FormConstraintAuthorizationConfigFrame;
+    /**
+     * This form field is included when the displayed form is in one of these modes.
+     * If this is not specified, the form field will be included in all modes.
+     */
+    allowModes?: FormModesConfig[];
+}
+export interface FormConstraintConfigOutline extends FormConstraintConfigFrame {
+    authorization?: FormConstraintAuthorizationConfigOutline;
+}
+export interface FormConstraintAuthorizationConfigFrame {
+    /**
+     * The current user must have at least one of these roles for the form field to be included.
+     *
+     * e.g. allowRoles: ['Admin', 'Librarians'],
+     */
+    allowRoles?: string[];
+}
+export interface FormConstraintAuthorizationConfigOutline extends FormConstraintAuthorizationConfigFrame {
+}
+/**
+ * The classes to transform to for each item that requires a class.
+ */
+export type FormOverrideModeClassesConfig = {
+    component?: ComponentClassNamesType;
+    model?: ModelClassNamesType;
+    layout?: LayoutClassNamesType;
+};
+/**
+ * The form mode to class name mapping.
+ */
+export type FormOverrideModesClassConfig = Partial<{
+    [key in FormModesConfig]: FormOverrideModeClassesConfig;
+}>;
+/**
+ * The available options for overriding the form config.
+ */
+export interface FormOverrideConfigFrame {
+    /**
+     * Replace the form component name property value with the value of this property.
+     */
+    replaceName?: string;
+    /**
+     * When the form mode is the object key (one of the form modes), set the class as per the value object.
+     */
+    formModeClasses?: FormOverrideModesClassConfig;
+    /**
+     * The name of the reusable form config to insert in place of this element.
+     */
+    reusableFormName?: string;
+}
+export interface FormOverrideConfigOutline extends FormOverrideConfigFrame {
+}
+/**
+ * The form component interface that provides typing for the object literal and schema.
+ */
+export interface FormComponentDefinitionFrame {
+    /**
+     * top-level field name, applies to field and the component, etc.
+     */
+    name: string;
+    /**
+     * The definition of the model that backs the form field.
+     */
+    model?: FieldModelDefinitionFrame<unknown>;
+    /**
+     * The definition of the client-side component for the form field.
+     */
+    component: FieldComponentDefinitionFrame;
+    /**
+     * The definition of the client-side layout for this form field.
+     */
+    layout?: FieldLayoutDefinitionFrame;
+    /**
+     * A record with string keys and expression template values for defining expressions.
+     */
+    expressions?: FormExpressionsConfigFrame[];
+    /**
+     * For a custom form component definition, module defines where to find the definition.
+     */
+    module?: string;
+    /**
+     * Constraints / prerequisites for this component to be included in the form definition.
+     */
+    constraints?: FormConstraintConfigFrame;
+    /**
+     * Optional ways to extend or replace parts of the form config.
+     */
+    overrides?: FormOverrideConfigFrame;
+}
+export interface FormComponentDefinitionOutline extends FormComponentDefinitionFrame, CanVisit {
+    model?: FieldModelDefinitionOutline<unknown>;
+    component: FieldComponentDefinitionOutline;
+    layout?: FieldLayoutDefinitionOutline;
+    expressions?: FormExpressionsConfigOutline[];
+    constraints?: FormConstraintConfigOutline;
+    overrides?: FormOverrideConfigOutline;
+}
+export {};

package/dist/src/config/form-component.outline.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormExpressionsTargetValidationGroups = exports.FormExpressionsTargetComponentPrefix = exports.FormExpressionsTargetLayoutPrefix = exports.FormExpressionsTargetModelValue = exports.ExpressionsConditionKind = void 0;
+/**
+ * The kinds of conditions available for expressions.
+ *
+ * JSONPointer - Uses JSON Pointer syntax to point to a value in the form data. For wiring events between fields, this is often sufficient. This is simple and fast to evaluate.
+ *
+ * JSONata - Uses the JSONata query and transformation language to evaluate more complex conditions based on data supplied at evaluation time. Template must resolve to a truthy value. This is more powerful but may be slower to evaluate.
+ *
+ * JSONataQuery - Similar to JSONata, but uses the FormComponent.componentDefQuerySource in addition to those supplied at evaluation time. This is useful for conditions that depend on multiple fields or the structure of the form itself.
+ *
+ * @see FormExpressionsConfigFrame.conditionKind
+ */
+exports.ExpressionsConditionKind = {
+    JSONPointer: "jsonpointer",
+    JSONata: "jsonata",
+    JSONataQuery: "jsonata_query",
+};
+exports.FormExpressionsTargetModelValue = "model.value";
+exports.FormExpressionsTargetLayoutPrefix = "layout.";
+exports.FormExpressionsTargetComponentPrefix = "component.";
+exports.FormExpressionsTargetValidationGroups = "form.enabledValidationGroups";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1jb21wb25lbnQub3V0bGluZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZm9ybS1jb21wb25lbnQub3V0bGluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFRQTs7Ozs7Ozs7OztHQVVHO0FBQ1UsUUFBQSx3QkFBd0IsR0FBRztJQUNwQyxXQUFXLEVBQUUsYUFBYTtJQUMxQixPQUFPLEVBQUUsU0FBUztJQUNsQixZQUFZLEVBQUUsZUFBZTtDQUN2QixDQUFDO0FBK0RFLFFBQUEsK0JBQStCLEdBQUcsYUFBc0IsQ0FBQztBQVN6RCxRQUFBLGlDQUFpQyxHQUFHLFNBQWtCLENBQUM7QUFRdkQsUUFBQSxvQ0FBb0MsR0FBRyxZQUFxQixDQUFDO0FBUTdELFFBQUEscUNBQXFDLEdBQUcsOEJBQXVDLENBQUMifQ==

package/dist/src/config/form-config.model.d.ts

@@ -0,0 +1,33 @@
+import { FormValidationGroups, FormValidatorConfig } from '../validation/form.model';
+import { AvailableFormComponentDefinitionOutlines } from './dictionary.outline';
+import { FormConfigOutline } from './form-config.outline';
+import { FormConfigVisitorOutline } from './visitor/base.outline';
+import { KeyValueStringNested, KeyValueStringProperty } from './shared.outline';
+import { FormExpressionsConfigOutline } from './form-component.outline';
+import { FormBehaviourConfigFrame } from './form-behaviour.outline';
+/**
+ * The form definition.
+ * */
+export declare class FormConfig implements FormConfigOutline {
+    name: string;
+    type?: string;
+    domElementType?: string;
+    domId?: string;
+    viewCssClasses?: KeyValueStringProperty;
+    editCssClasses?: KeyValueStringProperty;
+    defaultComponentConfig?: KeyValueStringNested;
+    defaultLayoutComponent?: string;
+    enabledValidationGroups?: string[];
+    validators: FormValidatorConfig[];
+    validationGroups?: FormValidationGroups;
+    componentDefinitions: AvailableFormComponentDefinitionOutlines[];
+    debugValue: boolean;
+    expressions?: FormExpressionsConfigOutline[];
+    /**
+     * Top-level behaviour config copied during construct and then transformed by
+     * the template/client visitors before reaching the Angular runtime.
+     */
+    behaviours?: FormBehaviourConfigFrame[];
+    attachmentFields?: string[];
+    accept(visitor: FormConfigVisitorOutline): void;
+}

package/dist/src/config/form-config.model.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormConfig = void 0;
+/**
+ * The form definition.
+ * */
+class FormConfig {
+    name = '';
+    type;
+    domElementType;
+    domId;
+    viewCssClasses;
+    editCssClasses;
+    defaultComponentConfig;
+    defaultLayoutComponent;
+    enabledValidationGroups = ['all'];
+    validators = [];
+    validationGroups = {
+        all: { description: 'Validate all fields with validators.', initialMembership: 'all' },
+        none: { description: 'Validate none of the fields.', initialMembership: 'none' },
+    };
+    componentDefinitions = [];
+    debugValue = false;
+    expressions;
+    /**
+     * Top-level behaviour config copied during construct and then transformed by
+     * the template/client visitors before reaching the Angular runtime.
+     */
+    behaviours;
+    attachmentFields;
+    accept(visitor) {
+        visitor.visitFormConfig(this);
+    }
+}
+exports.FormConfig = FormConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1jb25maWcubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29uZmlnL2Zvcm0tY29uZmlnLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVFBOztLQUVLO0FBQ0wsTUFBYSxVQUFVO0lBQ2QsSUFBSSxHQUFXLEVBQUUsQ0FBQztJQUNsQixJQUFJLENBQVU7SUFDZCxjQUFjLENBQVU7SUFDeEIsS0FBSyxDQUFVO0lBQ2YsY0FBYyxDQUEwQjtJQUN4QyxjQUFjLENBQTBCO0lBQ3hDLHNCQUFzQixDQUF3QjtJQUM5QyxzQkFBc0IsQ0FBVTtJQUNoQyx1QkFBdUIsR0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdDLFVBQVUsR0FBMEIsRUFBRSxDQUFDO0lBQ3ZDLGdCQUFnQixHQUEwQjtRQUMvQyxHQUFHLEVBQUUsRUFBRSxXQUFXLEVBQUUsc0NBQXNDLEVBQUUsaUJBQWlCLEVBQUUsS0FBSyxFQUFFO1FBQ3RGLElBQUksRUFBRSxFQUFFLFdBQVcsRUFBRSw4QkFBOEIsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLEVBQUU7S0FDakYsQ0FBQztJQUNLLG9CQUFvQixHQUErQyxFQUFFLENBQUM7SUFDdEUsVUFBVSxHQUFZLEtBQUssQ0FBQztJQUM1QixXQUFXLENBQWtDO0lBQ3BEOzs7T0FHRztJQUNJLFVBQVUsQ0FBOEI7SUFFeEMsZ0JBQWdCLENBQVk7SUFFbkMsTUFBTSxDQUFDLE9BQWlDO1FBQ3RDLE9BQU8sQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBN0JELGdDQTZCQyJ9