@bpmn-io/form-js-viewer 1.5.0 → 1.6.1

package/dist/types/Form.d.ts

@@ -27,8 +27,15 @@ export default class Form {
      * @type {State}
      */
     private _state;
-    get: <T>(name: string, strict?: boolean) => T;
-    invoke: <T_1>(func: (...args: any[]) => T_1, context?: unknown, locals?: import("didi").LocalsMap) => T_1;
+    get: {
+        <T>(name: string): T;
+        <T_1>(name: string, strict: true): T_1;
+        <T_2>(name: string, strict: boolean): T_2;
+    };
+    invoke: {
+        <T_3>(func: import("didi").FactoryFunction<T_3>, context?: unknown, locals?: import("didi").LocalsMap): T_3;
+        <T_4>(func: import("didi").ArrayFunc<T_4>, context?: unknown, locals?: import("didi").LocalsMap): T_4;
+    };
     clear(): void;
     /**
      * Destroy the form, removing it from DOM,
@@ -95,11 +102,12 @@ export default class Form {
     /**
      * @internal
      *
-     * @param { { add?: boolean, field: any, remove?: number, value?: any } } update
+     * @param { { add?: boolean, field: any, indexes: object, remove?: number, value?: any } } update
      */
     _update(update: {
         add?: boolean;
         field: any;
+        indexes: object;
         remove?: number;
         value?: any;
     }): void;
@@ -126,6 +134,9 @@ export default class Form {
         __depends__: import("didi").ModuleDeclaration[];
         __init__: string[];
         viewerCommands: (string | typeof import("./features").ViewerCommands)[];
+    } | {
+        __init__: string[];
+        repeatRenderManager: (string | typeof import("./features").RepeatRenderManager)[];
     })[];
     /**
      * @internal
@@ -142,7 +153,7 @@ export default class Form {
     /**
      * @internal
      */
-    _initializeFieldData(data: any): any;
+    _getInitializedFieldData(data: any, options?: {}): any;
 }
 export type Injector = import('./types').Injector;
 export type Data = import('./types').Data;

package/dist/types/core/FieldFactory.d.ts

@@ -12,6 +12,8 @@ declare class FieldFactory {
     create(attrs: any, applyDefaults?: boolean): any;
     _ensureId(field: any): void;
     _ensureKey(field: any): void;
+    _enforceDefaultPath(field: any): void;
+    _getUniqueKeyPath(field: any): string;
 }
 declare namespace FieldFactory {
     let $inject: string[];

package/dist/types/core/FormFieldRegistry.d.ts

@@ -7,6 +7,7 @@ declare class FormFieldRegistry {
     remove(formField: any): void;
     get(id: any): any;
     getAll(): any[];
+    getForm(): any;
     forEach(callback: any): void;
     clear(): void;
 }

package/dist/types/core/PathRegistry.d.ts

@@ -30,12 +30,13 @@
  *   ]
  */
 declare class PathRegistry {
-    constructor(formFieldRegistry: any, formFields: any);
+    constructor(formFieldRegistry: any, formFields: any, injector: any);
     _formFieldRegistry: any;
     _formFields: any;
+    _injector: any;
     _dataPaths: any[];
-    canClaimPath(path: any, closed?: boolean): boolean;
-    claimPath(path: any, closed?: boolean): void;
+    canClaimPath(path: any, options?: {}): boolean;
+    claimPath(path: any, options?: {}): void;
     unclaimPath(path: any): void;
     /**
      * Applies a function (fn) recursively on a given field and its children.
@@ -55,15 +56,18 @@ declare class PathRegistry {
      * @param {Object} field - The field object with properties: `key`, `path`, `id`, and optionally `_parent`.
      * @param {Object} [options={}] - Configuration options.
      * @param {Object} [options.replacements={}] - A map of field IDs to alternative path arrays.
+     * @param {Object} [options.indexes=null] - A map of parent IDs to the index of the field within said parent, leave null to get an unindexed path.
      * @param {Object} [options.cutoffNode] - The ID of the parent field at which to stop generating the path.
      *
      * @returns {(Array<string>|undefined)} An array of strings representing the binding path, or undefined if not determinable.
      */
     getValuePath(field: any, options?: {
         replacements?: any;
+        indexes?: any;
         cutoffNode?: any;
     }): (Array<string> | undefined);
     clear(): void;
+    _addIndexes(localValuePath: any, field: any, indexes: any): any;
 }
 declare namespace PathRegistry {
     let $inject: string[];

package/dist/types/features/{expression-language → expressionLanguage}/ConditionChecker.d.ts

@@ -10,17 +10,19 @@ declare class ConditionChecker {
     /**
      * For given data, remove properties based on condition.
      *
-     * @param {Object<string, any>} properties
      * @param {Object<string, any>} data
+     * @param {Object<string, any>} contextData
      * @param {Object} [options]
      * @param {Function} [options.getFilterPath]
+     * @param {boolean} [options.leafNodeDeletionOnly]
      */
-    applyConditions(properties: {
+    applyConditions(data: {
         [x: string]: any;
-    }, data?: {
+    }, contextData?: {
         [x: string]: any;
     }, options?: {
         getFilterPath?: Function;
+        leafNodeDeletionOnly?: boolean;
     }): {
         [x: string]: any;
     };
@@ -43,7 +45,9 @@ declare class ConditionChecker {
     _checkHideCondition(condition: Condition, data: {
         [x: string]: any;
     }): boolean;
-    _clearObjectValueRecursively(valuePath: any, obj: any): void;
+    _cleanlyClearDataAtPath(valuePath: any, obj: any): void;
+    _isEmptyObject(parentObject: any): boolean;
+    _isEmptyArray(parentObject: any): boolean;
 }
 declare namespace ConditionChecker {
     let $inject: string[];

package/dist/types/features/index.d.ts

@@ -1,6 +1,8 @@
-export { default as ExpressionLanguageModule } from "./expression-language";
+export { default as ExpressionLanguageModule } from "./expressionLanguage";
 export { default as MarkdownModule } from "./markdown";
 export { default as ViewerCommandsModule } from "./viewerCommands";
-export * from "./expression-language";
+export { default as RepeatRenderModule } from "./repeatRender";
+export * from "./expressionLanguage";
 export * from "./markdown";
 export * from "./viewerCommands";
+export * from "./repeatRender";

package/dist/types/features/repeatRender/RepeatRenderManager.d.ts

@@ -0,0 +1,21 @@
+declare class RepeatRenderManager {
+    constructor(form: any, formFields: any, formFieldRegistry: any, pathRegistry: any);
+    _form: any;
+    _formFields: any;
+    _formFieldRegistry: any;
+    _pathRegistry: any;
+    Repeater(props: any): import("preact").JSX.Element;
+    RepeatFooter(props: any): import("preact").JSX.Element;
+    /**
+     * Checks whether a field is currently repeating its children.
+     *
+     * @param {string} id - The id of the field to check
+     * @returns {boolean} - True if repeatable, false otherwise
+     */
+    isFieldRepeating(id: string): boolean;
+    _getNonCollapsedItems(field: any): any;
+}
+declare namespace RepeatRenderManager {
+    let $inject: string[];
+}
+export default RepeatRenderManager;

package/dist/types/features/repeatRender/index.d.ts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    let __init__: string[];
+    let repeatRenderManager: (string | typeof RepeatRenderManager)[];
+}
+export default _default;
+export { RepeatRenderManager };
+import RepeatRenderManager from './RepeatRenderManager';

package/dist/types/features/viewerCommands/ViewerCommands.d.ts

@@ -5,7 +5,7 @@ declare class ViewerCommands {
     getHandlers(): {
         'formField.validation.update': typeof UpdateFieldValidationHandler;
     };
-    updateFieldValidation(field: any, value: any): void;
+    updateFieldValidation(field: any, value: any, indexes: any): void;
 }
 declare namespace ViewerCommands {
     let $inject: string[];

package/dist/types/index.d.ts

@@ -14,6 +14,6 @@ export * from "./util";
 export * from "./features";
 export type CreateFormOptions = import('./types').CreateFormOptions;
 import Form from './Form';
-export const schemaVersion: 13;
+export const schemaVersion: 14;
 export { Form };
 export { FormFieldRegistry, FormLayouter, Importer, FieldFactory, PathRegistry } from "./core";

package/dist/types/render/components/Label.d.ts

@@ -1 +1,21 @@
-export default function Label(props: any): import("preact").JSX.Element;
+/**
+ * @typedef Props
+ * @property {string} [id]
+ * @property {string|undefined} label
+ * @property {string} [class]
+ * @property {boolean} [collapseOnEmpty]
+ * @property {boolean} [required]
+ * @property {import("preact").VNode} [children]
+ *
+ * @param {Props} props
+ * @returns {import("preact").JSX.Element}
+ */
+export default function Label(props: Props): import("preact").JSX.Element;
+export type Props = {
+    id?: string;
+    label: string | undefined;
+    class?: string;
+    collapseOnEmpty?: boolean;
+    required?: boolean;
+    children?: import("preact").VNode;
+};

package/dist/types/render/components/Util.d.ts

@@ -4,4 +4,4 @@ export function formFieldClasses(type: any, { errors, disabled, readonly }?: {
     readonly?: boolean;
 }): any;
 export function gridColumnClasses(formField: any): any;
-export function prefixId(id: any, formId: any): string;
+export function prefixId(id: any, formId: any, indexes: any): string;

package/dist/types/render/components/form-fields/DynamicList.d.ts

@@ -0,0 +1,18 @@
+declare function DynamicList(props: any): import("preact").JSX.Element;
+declare namespace DynamicList {
+    namespace config {
+        let type: string;
+        let pathed: boolean;
+        let repeatable: boolean;
+        let label: string;
+        let group: string;
+        function create(options?: {}): {
+            components: any[];
+            showOutline: boolean;
+            isRepeating: boolean;
+            allowAddRemove: boolean;
+            defaultRepetitions: number;
+        };
+    }
+}
+export default DynamicList;

package/dist/types/render/components/form-fields/Table.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @typedef {('asc'|'desc')} Direction
+ *
+ * @typedef Sorting
+ * @property {string} key
+ * @property {Direction} direction
+ *
+ * @typedef Column
+ * @property {string} label
+ * @property {string} key
+ *
+ * @typedef Props
+ * @property {Object} field
+ * @property {string} field.id
+ * @property {Array<Column>} [field.columns]
+ * @property {string} [field.columnsExpression]
+ * @property {string} [field.label]
+ * @property {number} [field.rowCount]
+ * @property {string} [field.dataSource]
+ *
+ * @param {Props} props
+ * @returns {import("preact").JSX.Element}
+ */
+declare function Table(props: Props): import("preact").JSX.Element;
+declare namespace Table {
+    namespace config {
+        export { type };
+        export let keyed: boolean;
+        export let label: string;
+        export let group: string;
+        export function create(options?: {}): {
+            id: any;
+            columnsExpression: string;
+        } | {
+            id: any;
+            columns: Column[];
+        } | {
+            rowCount: number;
+            columns: {
+                label: string;
+                key: string;
+            }[];
+        };
+        export let initialDemoData: {
+            id: number;
+            name: string;
+            date: string;
+        }[];
+    }
+}
+export default Table;
+export type Direction = ('asc' | 'desc');
+export type Sorting = {
+    key: string;
+    direction: Direction;
+};
+export type Column = {
+    label: string;
+    key: string;
+};
+export type Props = {
+    field: {
+        id: string;
+        columns?: Array<Column>;
+        columnsExpression?: string;
+        label?: string;
+        rowCount?: number;
+        dataSource?: string;
+    };
+};
+declare const type: "table";

package/dist/types/render/components/form-fields/parts/ChildrenRenderer.d.ts

@@ -0,0 +1 @@
+export default function ChildrenRenderer(props: any): import("preact").JSX.Element;

package/dist/types/render/components/index.d.ts

@@ -13,6 +13,7 @@ import FormComponent from './FormComponent';
 import FormField from './FormField';
 import Group from './form-fields/Group';
 import IFrame from './form-fields/IFrame';
+import DynamicList from './form-fields/DynamicList';
 import Image from './form-fields/Image';
 import Numberfield from './form-fields/Number';
 import Radio from './form-fields/Radio';
@@ -23,4 +24,5 @@ import Taglist from './form-fields/Taglist';
 import Text from './form-fields/Text';
 import Textfield from './form-fields/Textfield';
 import Textarea from './form-fields/Textarea';
-export { Label, Description, Errors, Button, Checkbox, Checklist, Default, Datetime, FormComponent, FormField, Group, IFrame, Image, Numberfield, Radio, Select, Separator, Spacer, Taglist, Text, Textfield, Textarea };
+import Table from './form-fields/Table';
+export { Label, Description, Errors, Button, Checkbox, Checklist, Default, Datetime, FormComponent, FormField, Group, IFrame, DynamicList, Image, Numberfield, Radio, Select, Separator, Spacer, Taglist, Text, Textfield, Textarea, Table };

package/dist/types/render/context/FormRenderContext.d.ts

@@ -1,11 +1,12 @@
 export default FormRenderContext;
 declare const FormRenderContext: import("preact").Context<{
-    EmptyRoot: (props: any) => any;
     Empty: (props: any) => any;
+    Hidden: (props: any) => any;
     Children: (props: any) => import("preact").JSX.Element;
     Element: (props: any) => import("preact").JSX.Element;
     Row: (props: any) => import("preact").JSX.Element;
     Column: (props: any) => any;
-    hoveredId: any[];
-    setHoveredId: (newValue: any) => void;
+    hoverInfo: {
+        cleanup: () => void;
+    };
 }>;

package/dist/types/render/context/LocalExpressionContext.d.ts

@@ -0,0 +1,7 @@
+export default LocalExpressionContext;
+declare const LocalExpressionContext: import("preact").Context<{
+    data: any;
+    this: any;
+    parent: any;
+    i: any;
+}>;

package/dist/types/render/context/index.d.ts

@@ -1,2 +1,3 @@
 export { default as FormRenderContext } from "./FormRenderContext";
+export { default as LocalExpressionContext } from "./LocalExpressionContext";
 export { default as FormContext } from "./FormContext";

package/dist/types/render/hooks/index.d.ts

@@ -1,4 +1,5 @@
 export { default as useCondition } from "./useCondition";
+export { default as useScrollIntoView } from "./useScrollIntoView";
 export { default as useExpressionEvaluation } from "./useExpressionEvaluation";
 export { default as useFilteredFormData } from "./useFilteredFormData";
 export { default as useKeyDownAction } from "./useKeyDownAction";

package/dist/types/render/hooks/useExpressionEvaluation.d.ts

@@ -1,9 +1,9 @@
 /**
  * Evaluate a string reactively based on the expressionLanguage and form data.
  * If the string is not an expression, it is returned as is.
- * Memoised to minimize re-renders.
- *
- * @param {string} value
+ * The function is memoized to minimize re-renders.
  *
+ * @param {string} value - The string to evaluate.
+ * @returns {any} - Evaluated value or the original value if not an expression.
  */
 export default function useExpressionEvaluation(value: string): any;

package/dist/types/render/hooks/useFilteredFormData.d.ts

@@ -2,5 +2,6 @@
  * Returns the conditionally filtered data of a form reactively.
  * Memoised to minimize re-renders
  *
+ * Warning: costly operation, use with care
  */
 export default function useFilteredFormData(): any;

package/dist/types/render/hooks/useScrollIntoView.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Custom hook to scroll an element into view only when it is not visible within the viewport.
+ *
+ * @param {Object} targetRef - A ref pointing to the DOM element to scroll into view.
+ * @param {Array} deps - An array of dependencies that trigger the effect.
+ * @param {Array} flagRefs - An array of refs that are used as flags to control when to scroll.
+ * @param {Object} [scrollOptions={}] - Options defining the behavior of the scrolling.
+ * @param {String} [scrollOptions.align='center'] - The alignment of the element within the viewport.
+ * @param {String} [scrollOptions.behavior='auto'] - The scrolling behavior.
+ * @param {Number} [scrollOptions.offset=0] - An offset that is added to the scroll position.
+ * @param {Boolean} [scrollOptions.scrollIfVisible=false] - Whether to scroll even if the element is visible.
+ */
+export default function useScrollIntoView(targetRef: any, deps: any[], scrollOptions?: {
+    align?: string;
+    behavior?: string;
+    offset?: number;
+    scrollIfVisible?: boolean;
+}, flagRefs?: any[]): void;

package/dist/types/render/hooks/useTemplateEvaluation.d.ts

@@ -9,7 +9,7 @@
  * @param {Function} [options.buildDebugString]
  *
  */
-export default function useTemplateEvaluation(value: string, options: {
+export default function useTemplateEvaluation(value: string, options?: {
     debug?: boolean;
     strict?: boolean;
     buildDebugString?: Function;

package/dist/types/types.d.ts

@@ -1,36 +1,36 @@
-import { Injector } from 'didi';
-
-export type Module = any;
-export type Schema = any;
-
-export interface Data {
-  [x: string]: any;
-}
-
-export interface Errors {
-  [x: string]: string[];
-}
-
-export type FormProperty = ('readOnly' | 'disabled' | string);
-export type FormEvent = ('submit' | 'changed' | string);
-
-export interface FormProperties {
-  [x: string]: any;
-}
-
-export interface FormOptions {
-  additionalModules?: Module[];
-  container?: Element | null | string;
-  injector?: Injector;
-  modules?: Module[];
-  properties?: FormProperties;
-}
-
-export interface CreateFormOptions extends FormOptions {
-  data?: Data;
-  schema: Schema;
-}
-
-export {
-  Injector
+import { Injector } from 'didi';
+
+export type Module = any;
+export type Schema = any;
+
+export interface Data {
+  [x: string]: any;
+}
+
+export interface Errors {
+  [x: string]: string[];
+}
+
+export type FormProperty = ('readOnly' | 'disabled' | string);
+export type FormEvent = ('submit' | 'changed' | string);
+
+export interface FormProperties {
+  [x: string]: any;
+}
+
+export interface FormOptions {
+  additionalModules?: Module[];
+  container?: Element | null | string;
+  injector?: Injector;
+  modules?: Module[];
+  properties?: FormProperties;
+}
+
+export interface CreateFormOptions extends FormOptions {
+  data?: Data;
+  schema: Schema;
+}
+
+export {
+  Injector
 };

package/dist/types/util/constants/OptionsSourceConstants.d.ts

@@ -0,0 +1,19 @@
+export function getOptionsSource(field: any): string;
+export namespace OPTIONS_SOURCES {
+    let STATIC: string;
+    let INPUT: string;
+    let EXPRESSION: string;
+}
+export const OPTIONS_SOURCE_DEFAULT: string;
+export const OPTIONS_SOURCES_LABELS: {
+    [x: string]: string;
+};
+export const OPTIONS_SOURCES_PATHS: {
+    [x: string]: string[];
+};
+export const OPTIONS_SOURCES_DEFAULTS: {
+    [x: string]: string | {
+        label: string;
+        value: string;
+    }[];
+};

package/dist/types/util/constants/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./DatetimeConstants";
-export * from "./ValuesSourceConstants";
+export * from "./OptionsSourceConstants";

package/dist/types/util/getSchemaVariables.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @typedef { import('../types').Schema } Schema
+ */
+/**
+ * Parse the schema for variables a form might make use of.
+ *
+ * @example
+ *
+ * // retrieve variables from schema
+ * const variables = getSchemaVariables(schema);
+ *
+ * @example
+ *
+ * // retrieve input variables from schema
+ * const inputVariables = getSchemaVariables(schema, { outputs: false });
+ *
+ * @example
+ *
+ * // retrieve output variables from schema
+ * const outputVariables = getSchemaVariables(schema, { inputs: false });
+ *
+ * @param {Schema} schema
+ * @param {object} [options]
+ * @param {any} [options.expressionLanguage]
+ * @param {any} [options.templating]
+ * @param {any} [options.formFields]
+ * @param {boolean} [options.inputs=true]
+ * @param {boolean} [options.outputs=true]
+ *
+ * @return {string[]}
+ */
+export function getSchemaVariables(schema: Schema, options?: {
+    expressionLanguage?: any;
+    templating?: any;
+    formFields?: any;
+    inputs?: boolean;
+    outputs?: boolean;
+}): string[];
+export type Schema = import('../types').Schema;

package/dist/types/util/index.d.ts

@@ -1,55 +1,6 @@
-export function isRequired(field: any): any;
-export function pathParse(path: any): any;
-export function pathsEqual(a: any, b: any): any;
-export function generateIndexForType(type: any): any;
-export function generateIdForType(type: any): string;
-/**
- * @template T
- * @param {T} data
- * @param {(this: any, key: string, value: any) => any} [replacer]
- * @return {T}
- */
-export function clone<T>(data: T, replacer?: (this: any, key: string, value: any) => any): T;
-/**
- * @typedef { import('../types').Schema } Schema
- */
-/**
- * Parse the schema for variables a form might make use of.
- *
- * @example
- *
- * // retrieve variables from schema
- * const variables = getSchemaVariables(schema);
- *
- * @example
- *
- * // retrieve input variables from schema
- * const inputVariables = getSchemaVariables(schema, { outputs: false });
- *
- * @example
- *
- * // retrieve output variables from schema
- * const outputVariables = getSchemaVariables(schema, { inputs: false });
- *
- * @param {Schema} schema
- * @param {object} [options]
- * @param {any} [options.expressionLanguage]
- * @param {any} [options.templating]
- * @param {any} [options.formFields]
- * @param {boolean} [options.inputs=true]
- * @param {boolean} [options.outputs=true]
- *
- * @return {string[]}
- */
-export function getSchemaVariables(schema: Schema, options?: {
-    expressionLanguage?: any;
-    templating?: any;
-    formFields?: any;
-    inputs?: boolean;
-    outputs?: boolean;
-}): string[];
-export function runRecursively(formField: any, fn: any): void;
 export * from "./constants";
 export * from "./injector";
 export * from "./form";
-export type Schema = import('../types').Schema;
+export * from "./getSchemaVariables";
+export * from "./simple";
+export * from "./structure";

package/dist/types/util/simple.d.ts

@@ -0,0 +1,20 @@
+export function isRequired(field: any): any;
+export function pathParse(path: any): any;
+export function pathsEqual(a: any, b: any): any;
+export function generateIndexForType(type: any): any;
+export function generateIdForType(type: any): string;
+/**
+ * @template T
+ * @param {T} data
+ * @param {(this: any, key: string, value: any) => any} [replacer]
+ * @return {T}
+ */
+export function clone<T>(data: T, replacer?: (this: any, key: string, value: any) => any): T;
+/**
+ * Transform a LocalExpressionContext object into a usable FEEL context.
+ *
+ * @param {Object} context - The LocalExpressionContext object.
+ * @returns {Object} The usable FEEL context.
+ */
+export function buildExpressionContext(context: any): any;
+export function runRecursively(formField: any, fn: any): void;

package/dist/types/util/structure.d.ts

@@ -0,0 +1 @@
+export function getAncestryList(formFieldId: string, formFieldRegistry: import('../core/FormFieldRegistry').default): Array<string>;