@formio/js 5.0.0-rc.5

package/types/components/schema.d.ts

@@ -0,0 +1,240 @@
+export interface ComponentSchema<T = any> {
+  /**
+   * The type of component
+   */
+  type?: string;
+
+  /**
+   * The data key for this component (how the data is stored in the database, referenced as API key in docs).
+   */
+  key?: string;
+
+  /**
+   * The HTML label to give this component.
+   */
+  label?: string;
+
+  /**
+   * The input placeholder for this component.
+   */
+  placeholder?: string;
+
+  /**
+   * Determines if this component provides an input.
+   */
+  input?: boolean;
+
+  /**
+   * If this component should be included as a column within a submission table.
+   * Determines if this field will show in the data tables output.
+   */
+  tableView?: boolean;
+
+  /**
+   * If this component should allow an array of values to be captured.
+   */
+  multiple?: boolean;
+
+  /**
+   * If the data of this component should be protected (no GET api requests can see the data)
+   */
+  protected?: boolean;
+
+  /**
+   * The prefix text to put in front of the input
+   */
+  prefix?: string;
+
+  /**
+   * The suffix text to put after the input
+   */
+  suffix?: string;
+
+  /**
+   * The default value of this compoennt.
+   */
+  defaultValue?: T;
+
+  /**
+   * If the value of this field should be cleared when it is conditionally hidden.
+   */
+  clearOnHide?: boolean;
+
+  /**
+   * Validate if the value of this component should be unique within the form.
+   */
+  unique?: boolean;
+
+  /**
+   * If the value of this component should be persisted within the backend api database.
+   */
+  persistent?: boolean;
+
+  /**
+   * Determines if the component should be within the form, but not visible.
+   * This can be overridden with the conditionals.
+   */
+  hidden?: boolean;
+
+  /**
+   * The validation criteria for this component.
+   */
+  validate?: ValidateOptions;
+
+  /**
+   * Determines when this component should be added to the form for both processing and input.
+   */
+  conditional?: ConditionalOptions;
+
+  /**
+   * Allows customizable errors to be displayed for each component when an error occurs. This is an object with the following keys:
+      required
+      min
+      max
+      minLength
+      maxLength
+      invalid_email
+      invalid_date
+      pattern
+      custom
+
+    An object (keys listed above), values are the strings you wish to display. Each string has the {{ field }} to use within the string. Example.
+    {"required": "{{ field }} is required. Try again."}
+   */
+  errors?: Object;
+
+  /**
+   * Allows changing the component definition in reaction to data entered in a form. For example, changing a field to required, disabled or hidden when a value is entered.
+    An array of instances of the Field Logic Schema
+    Fyi: https://github.com/formio/formio.js/wiki/Field-Logic-Schema
+   */
+  logic?: Object[];
+
+  /**
+   * The custom CSS class to provide to this component.
+   */
+  customClass?: string;
+
+  /**
+   * If true, will show label when component is in a datagrid.
+   */
+  dataGridLabel?: boolean;
+
+  labelPosition?: 'top' | 'bottom' | 'left' | 'right';
+  labelWidth?: number;
+  labelMargin?: number;
+  description?: string;
+  errorLabel?: string;
+  tooltip?: string;
+  hideLabel?: boolean;
+  tabindex?: string;
+  disabled?: boolean;
+  autofocus?: boolean;
+  dbIndex?: boolean;
+  customDefaultValue?: any;
+  calculateValue?: any;
+  allowCalculateOverride?: boolean;
+  widget?: any; // Input widgets i.e. calendar widget
+
+  /**
+   * This will refresh this component when this field changes.
+   */
+  refreshOn?: string;
+
+  /**
+   * Determines if we should clear our value when a refresh occurs.
+   */
+  clearOnRefresh?: boolean;
+
+  /**
+   * This will perform the validation on either "change" or "blur" of the input element.
+   */
+  validateOn?: 'change' | 'blur';
+}
+
+export type ExtendedComponentSchema<T = any> = ComponentSchema<T> & { [key: string]: any };
+
+export interface ConditionalOptions {
+  /** If the field should show if the condition is true */
+  show?: boolean;
+  /** The field API key that it should compare its value against to determine if the condition is triggered. */
+  when?: string;
+  /** The value that should be checked against the comparison component */
+  eq?: string;
+  /** The JSON Logic to determine if this component is conditionally available.
+   * Fyi: http://jsonlogic.com/
+   */
+  json?: Object;
+}
+
+export interface ValidateOptions {
+  /**
+   * If this component is required.
+   */
+  required?: boolean;
+
+  /**
+   * For text input, this checks the minimum length of text for valid input
+   */
+  minLength?: number;
+
+  /**
+   * For text input, this checks the maximum length of text for valid input
+   */
+  maxLength?: number;
+
+  /**
+   * For text input, this checks the text agains a Regular expression pattern.
+   */
+  pattern?: string;
+
+  /**
+   * A custom javascript based validation or a JSON object for using JSON Logic
+   */
+  custom?: any;
+
+  /**
+   * If the custom validation should remain private (only the backend will see it and execute it).
+   */
+  customPrivate?: boolean;
+
+  /**
+   * Minimum value for numbers
+   */
+  min?: number;
+
+  /**
+   * Maximum value for numbers
+   */
+  max?: number;
+
+  minSelectedCount?: number;
+  maxSelectedCount?: number;
+  minWords?: number;
+  maxWords?: number;
+  email?: boolean;
+  url?: boolean;
+  date?: boolean;
+  day?: boolean;
+  json?: string;
+  mask?: boolean;
+  minDate?: any;
+  maxDate?: any;
+}
+
+export interface ElementInfo {
+  type: string;
+  component: ExtendedComponentSchema;
+  changeEvent: string;
+  attr: any;
+  content: string;
+}
+
+export interface BuilderInfo {
+  title: string;
+  group: string;
+  icon: string;
+  documentation?: string;
+  weight?: number;
+  schema?: ExtendedComponentSchema;
+}

package/types/displays.d.ts

@@ -0,0 +1,7 @@
+export class Displays {
+  static readonly displays: any;
+  static addDisplay(name: string, display: any): void;
+  static addDisplays(name: string, display: any): void;
+  static getDisplay(name: string): any;
+  static getDisplays(name: string): any;
+}

package/types/element.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from './eventEmitter.d';
+
+export class Element {
+  options: Object;
+  id: string;
+  eventHandlers: any[];
+  i18next: any;
+  events: EventEmitter;
+  defaultMask: any;
+  inputMasks: any[];
+  constructor(options: any);
+  on(event: string, cb: Function, internal: boolean, once?: boolean): any;
+  once(event: string, cb: Function, internal: boolean): any;
+  onAny(cb: Function): any;
+  off(event: string): void;
+  emit(event: string, data: Object): void;
+  addEventListener(obj: HTMLElement, type: string, func: Function, persistent?: boolean): any;
+  removeEventListener(obj: Object, type: any): any;
+  removeEventListeners(): void;
+  removeAllEvents(includeExternal: boolean): void;
+  destroy(): void;
+  appendTo(element: HTMLElement, container: HTMLElement): any;
+  prependTo(element: HTMLElement, container: HTMLElement): any;
+  removeChildFrom(element: HTMLElement, container: HTMLElement): any;
+  ce(type: string, attr?: Object, children?: HTMLElement | string | Array<HTMLElement | string>): HTMLElement;
+  appendChild(element: any, child: any): any;
+  maskPlaceholder(mask: HTMLElement): string;
+  setInputMask(input: HTMLElement, inputMask: string, placeholder: boolean): void;
+  t(text: string, params?: Object): string;
+  text(text: string): Text;
+  attr(element: HTMLElement, attr: Object): void;
+  hasClass(element: HTMLElement | any, className: string): boolean;
+  addClass(element: HTMLElement, className: string): any;
+  removeClass(element: HTMLElement, className: string): any;
+  empty(element: HTMLElement): void;
+  evalContext(additional: any): any;
+  interpolate(string: any, data: any): any;
+  evaluate(
+    func: any,
+    args: { component: any; form: any; instance: any; row: any; data: any } | any,
+    ret: any,
+    tokenize?: any,
+  ): any;
+  hook(...args: any[]): any;
+}

package/types/eventEmitter.d.ts

@@ -0,0 +1,3 @@
+export class EventEmitter /* extends EventEmitter3 */ {
+  constructor(conf: Object);
+}

package/types/form.d.ts

@@ -0,0 +1,18 @@
+import { Element } from './element';
+
+export class Form extends Element {
+  form: any;
+  instance: any;
+  ready: Promise<any>;
+  constructor(...args: any[]);
+  create(display: 'wizard' | 'form' | 'pdf'): any;
+  setForm(formParam: any): any;
+  setDisplay(display: any): any;
+  empty(): void;
+  render(): any | Promise<any>;
+  static embed(element: any): any;
+  sanitize(dirty: string): any;
+  setContent(element: any, content: any): boolean;
+  build(): Promise<any>;
+  attach(element: any): any | Promise<any>;
+}

package/types/formbuilder.d.ts

@@ -0,0 +1,6 @@
+import { Form } from './form';
+
+export class FormBuilder extends Form {
+  constructor(element: any, form: any, options: any);
+  create(display: string): any;
+}

package/types/formio.d.ts

@@ -0,0 +1,119 @@
+export class Formio {
+  constructor(url: string, options?: Object);
+  public base: string;
+  public projectsUrl: string;
+  public projectUrl: string;
+  public projectId: string;
+  public formId: string;
+  public submissionId: string;
+  public actionsUrl: string;
+  public actionId: string;
+  public actionUrl: string;
+  public vsUrl: string;
+  public vId: string;
+  public vUrl: string;
+  public query: string;
+  public formUrl?: string;
+  public formsUrl?: string;
+  public submissionUrl?: string;
+  public submissionsUrl?: string;
+  public token: any | string;
+  static libraries: any;
+  static Promise: any;
+  static fetch: any;
+  static Headers: any;
+  static baseUrl: string;
+  static projectUrl: string;
+  static authUrl: string;
+  static projectUrlSet: boolean;
+  static plugins: any;
+  static cache: any;
+  static providers: any;
+  static events: any; // EventEmitter3
+  static namespace: string;
+  static formOnly?: boolean;
+  static rulesEntities: any;
+  delete(type: any, opts?: any): any;
+  index(type: any, query?: any, opts?: any): any;
+  save(type: any, data: any, opts?: any): any;
+  load(type: any, query?: any, opts?: any): any;
+  makeRequest(...args: any[]): any;
+  loadProject(query?: any, opts?: any): any;
+  saveProject(data: any, opts?: any): any;
+  deleteProject(opts?: any): any;
+  static loadProjects(query?: any, opts?: any): any;
+  static createForm(element: any, form: string | Object, options?: Object): Promise<any>;
+  static setBaseUrl(url: string): void;
+  static setProjectUrl(url: string): void;
+  static setAuthUrl(url: string): void;
+  static getToken(options?: any): any;
+  static makeStaticRequest(url: string, method?: string, data?: any, opts?: Object): any;
+  static makeRequest(formio?: Formio, type?: string, url?: string, method?: string, data?: any, opts?: Object): any;
+  static currentUser(formio?: Formio, options?: Object): any;
+  static logout(formio?: Formio, options?: Object): any;
+  static clearCache(): void;
+  static setUser(user: any, opts?: Object): any;
+  loadForm(query?: any, opts?: Object): any;
+  loadForms(query?: any, opts?: Object): any;
+  loadSubmission(query?: any, opts?: Object): any;
+  loadSubmissions(query?: any, opts?: Object): any;
+  userPermissions(
+    user?: any,
+    form?: any,
+    submission?: any,
+  ): Promise<{ create: boolean; read: boolean; edit: boolean; delete: boolean }>;
+  createform(form: Object): Promise<any>;
+  saveForm(data: any, opts?: Object): any;
+  saveSubmission(data: any, opts?: Object): any;
+  deleteForm(opts?: Object): any;
+  deleteSubmission(opts?: Object): any;
+  saveAction(data: any, opts?: any): any;
+  deleteAction(opts?: any): any;
+  loadAction(query?: any, opts?: any): any;
+  loadActions(query?: any, opts?: any): any;
+  availableActions(): any;
+  actionInfo(name: any): any;
+  isObjectId(id: any): any;
+  getProjectId(): any;
+  getFormId(): any;
+  currentUser(options?: Object): any;
+  accessInfo(): any;
+  getToken(options?: Object): any;
+  setToken(token: any, options?: Object): any;
+  getTempToken(expire: any, allowed: any, options?: Object): any;
+  getDownloadUrl(form: any): any;
+  uploadFile(storage: any, file: any, fileName: any, dir: any, progressCallback: any, url: any, options?: Object): any;
+  downloadFile(file: any, options?: Object): any;
+  canSubmit(): any;
+  getUrlParts(url: any): any;
+  static use(plugin: any): any;
+  static getUrlParts(url: any, formio?: Formio): any;
+  static serialize(obj: any, _interpolate: any): any;
+  static getRequestArgs(formio: Formio, type: string, url: string, method?: string, data?: any, opts?: any): any;
+  static request(url: any, method?: any, data?: any, header?: any, opts?: any): any;
+  static setToken(token: string, opts?: any): any;
+  static getUser(options?: Object): any;
+  static getBaseUrl(): string;
+  static setApiUrl(url: string): any;
+  static getApiUrl(): any;
+  static setAppUrl(url: string): any;
+  static getAppUrl(): any;
+  static getProjectUrl(): any;
+  static noop(): any;
+  static identity(value: any): any;
+  static deregisterPlugin(plugin: any): any;
+  static registerPlugin(plugin: any, name: string): any;
+  static getPlugin(name: any | string): any;
+  static pluginWait(pluginFn: any, ...args: any[]): any;
+  static pluginGet(pluginFn: any, ...args: any[]): any;
+  static pluginAlter(pluginFn: any, value: any, ...args: any[]): any;
+  static accessInfo(formio?: Formio): any;
+  static pageQuery(): any;
+  static oAuthCurrentUser(formio?: Formio, token?: any): any;
+  static samlInit(options?: Object): any;
+  static oktaInit(options?: Object): any;
+  static ssoInit(type: any, options?: Object): any;
+  static requireLibrary(name: any, property: any, src: any, polling?: boolean): any;
+  static libraryReady(name: string): any;
+  oauthLogoutURI(uri: string, options?: any): any;
+}

package/types/index.d.ts

@@ -0,0 +1,17 @@
+export * from './components/components';
+export * from './components/schema';
+export * from './form';
+export * from './formbuilder';
+export * from './formio';
+export * from './templates';
+export * from './displays';
+export * from './widgets';
+export * from './utils';
+export * from './builders';
+export * from './rulesEngine/conjunctions';
+export * from './rulesEngine/operators';
+export * from './rulesEngine/quckRules';
+export * from './rulesEngine/rules';
+export * from './rulesEngine/transformers';
+export * from './rulesEngine/valueSources';
+export * from './providers';

package/types/providers.d.ts

@@ -0,0 +1,8 @@
+export class Providers {
+  static readonly providers: any;
+  static addProvider(type: string, name: string, provider:any): void;
+  static addProviders(type:string, providers: any): void;
+  static getProvider(type: string, name: string): any;
+  static getProviders(type: string): any;
+}
+

package/types/rulesEngine/conjunctions.d.ts

@@ -0,0 +1,7 @@
+export class Conjunctions {
+  static readonly conjunctions: any;
+  static addConjunction(name: string, conjunction: any): void;
+  static addConjunctions(conjunctions: any): void;
+  static getConjunction(name: string): any;
+  static getConjunctions(): any;
+}

package/types/rulesEngine/operators.d.ts

@@ -0,0 +1,7 @@
+export class Operators {
+  static readonly operators: any;
+  static addOperator(name: string, conjunction: any): void;
+  static addOperators(conjunctions: any): void;
+  static getOperator(name: string): any;
+  static getOperators(): any;
+}

package/types/rulesEngine/quckRules.d.ts

@@ -0,0 +1,7 @@
+export class QuickRules {
+  static readonly quickRules: any;
+  static addQuickRule(name: string, conjunction: any): void;
+  static addQuickRules(conjunctions: any): void;
+  static getQuickRule(name: string): any;
+  static getQuickRules(): any;
+}

package/types/rulesEngine/rules.d.ts

@@ -0,0 +1,7 @@
+export class Rules {
+  static readonly rules: any;
+  static addRule(name: string, conjunction: any): void;
+  static addRules(conjunctions: any): void;
+  static getRule(name: string): any;
+  static getRules(): any;
+}

package/types/rulesEngine/transformers.d.ts

@@ -0,0 +1,7 @@
+export class Transformers {
+  static readonly transformers: any;
+  static addTransformer(name: string, conjunction: any): void;
+  static addTransformers(conjunctions: any): void;
+  static getTransformer(name: string): any;
+  static getTransformers(): any;
+}

package/types/rulesEngine/valueSources.d.ts

@@ -0,0 +1,7 @@
+export class ValueSources {
+  static readonly valueSources: any;
+  static addValueSource(name: string, conjunction: any): void;
+  static addValueSources(conjunctions: any): void;
+  static getValueSource(name: string): any;
+  static getValueSources(): any;
+}

package/types/templates.d.ts

@@ -0,0 +1,8 @@
+export class Templates {
+  static readonly templates: any;
+  static addTemplate(name: string, template: any): void;
+  static setTemplate(name: string, template: any): void;
+  static current: any;
+  static readonly defaultTemplates: any;
+  static framework: any;
+}

package/types/utils.d.ts

@@ -0,0 +1,154 @@
+import * as moment from 'moment';
+
+export type AnyForJSON = { [key: string]: any } | any;
+
+export namespace Utils {
+  const ConditionOperators: any;
+  const Evaluator: any;
+  const _: any;
+  function evaluate(
+    func: any,
+    args: { component: any; form: any; instance: any; row: any; data: any } | any,
+    ret: any,
+    tokenize?: any,
+  ): any;
+  function getRandomComponentId(): string;
+  function getPropertyValue(style: CSSStyleDeclaration, prop: string): number;
+  function getElementRect(element: any): { x: number; y: number; width: number; height: number };
+  function boolValue(value: boolean | string): boolean;
+  function isMongoId(text: any): any;
+  function checkCalculated(component: { calculateValue?: any; key: any } | any, submission: any, rowData: any): void;
+  function checkSimpleConditional(
+    component: any /* unused */,
+    condition: { eq: any; show: any; when: any } & any,
+    row: any,
+    data: any,
+    instance: any
+  ): boolean;
+  function checkCustomConditional(
+    component: any /* unused */,
+    custom: string | any,
+    row: any,
+    data: any,
+    form: any,
+    variable: any,
+    onError: any,
+    instance: { evaluate?: any } | any,
+  ): any;
+  function checkJsonConditional(
+    component: { key: string | any } | any,
+    json: AnyForJSON,
+    row: any,
+    data: any,
+    form: any,
+    onError: any,
+  ): any;
+  function checkCondition(
+    component: { customConditional: any; conditional: { when: any; json: AnyForJSON } } | any,
+    row: any,
+    data: any,
+    form: any,
+    instance: any,
+  ): boolean;
+  function checkTrigger(
+    component: any,
+    trigger: { type: string; simple: any; json: AnyForJSON; javascript: any } | any,
+    row: any,
+    data: any,
+    form: any,
+    instance: any,
+  ): boolean | any;
+  function setActionProperty(
+    component: any,
+    action: { property: { type: string | any; value: any } | any; state: boolean | any; text: any },
+    row: any,
+    data: any,
+    result: any,
+    instance?: { interpolate: (textValue: any, evalData: any) => any | any },
+  ): any;
+  function interpolateTemplate(template: string): any;
+  function addTemplateHash(template: string): number;
+  function interpolate(rawTemplate: number | string, data: any): any;
+  function uniqueName(name: string, template: string, evalContext: Object): string;
+  function guid(): string;
+  function getDateSetting(date: any): null | Date;
+  function isValidDate(date: any): boolean;
+  function currentTimezone(): string;
+  function offsetDate(date: Date, timezone: string): { date: Date; abbr: string };
+  function zonesLoaded(): boolean;
+  function shouldLoadZones(timezone: string): boolean;
+  function loadZones(timezone?: string): Promise<undefined>;
+  function momentDate(value: moment.MomentInput, format: string, timezone: string): moment.Moment;
+  function formatDate(value: moment.MomentInput, format: string, timezone: string): string;
+  function formatOffset(
+    formatFn: (date: any, format: any) => string,
+    date: Date | any,
+    format: string | any,
+    timezone: string,
+  ): string;
+  function getLocaleDateFormatInfo(locale: string | string[]): { dayFirst: boolean };
+  function convertFormatToFlatpickr(format: string): string;
+  function convertFormatToMoment(format: string): string;
+  function convertFormatToMask(format: string): string;
+  function getInputMask(mask: string | RegExp[]): RegExp[];
+  function matchInputMask(value: string | RegExp, inputMask?: string | RegExp): boolean;
+  function getNumberSeparators(lang: string): { delimiter: string; decimalSeparator: string };
+  function getNumberDecimalLimit(component: any): number;
+  function getCurrencyAffixes(input: {
+    currency: string;
+    decimalLimit: number;
+    decimalSeparator: string;
+    lang: string | string[];
+  }): { prefix: string; suffix: string };
+  function fieldData(data: Object, component: { key: string | any[]; multiple: boolean | any } | any): any;
+  function delay(fn: Function, delay: number, args: any[]): any;
+  function iterateKey(key: string): string;
+  function uniqueKey(map: Object, base: string): string;
+  function bootstrapVersion(options: { bootstrap?: any } | any): number;
+  function unfold(e: any): any;
+  const firstNonNil: any;
+  function withSwitch(a: any, b: any): [Function, Function];
+  function observeOverload(callback: Function, options?: { limit?: number; delay?: number }): any;
+  function getContextComponents(context: any, excludeNested?: any, excludedTypes?: any): any;
+  function sanitize(string: string, options: any): any;
+
+  // Form Utils
+  function isLayoutComponent(component: { columns: any; rows: any; components: any } | any): boolean;
+  function eachComponent(components: any[], fn: Function, includeAll?: boolean, path?: string, parent?: Object): any;
+  function matchComponent(component: any, query: any): boolean;
+  function getComponent(components: any[], key: string | Object | any, includeAll: boolean): any;
+  function searchComponents(components: any[], query: any): any;
+  function findComponent(components: any[], key: any, path: any, fn: Function): boolean;
+  function removeComponent(components: any[], path: any): void;
+  function generateFormChange(
+    type: string | any,
+    data: { schema: any; parent: { key: any } | any; originalComponent: any },
+  ): {
+    op: string;
+    key: any;
+    container?: any;
+    index?: number;
+    component?: any;
+    patches?: any;
+  };
+  function applyFormChanges(form: any, changes: any[]): { form: any; failed: any[] };
+  function flattenComponents(components: any[], includeAll: boolean): any;
+  function hasCondition(component: any): boolean;
+  function parseFloatExt(value: any): number;
+  function formatAsCurrency(value: any): string;
+  function escapeRegExCharacters(value: string): string;
+  function getValue(submission: any, key: string): any;
+  function getStrings(
+    form: { components: any[] } | any,
+  ): { key: any; type?: any; property: string; string: string | any };
+
+  // Builder Utils
+  namespace BuilderUtils {
+    function uniquify(container: any[], component: any): boolean;
+    const additionalShortcuts: { button: ['Enter', 'Esc'] };
+    function getAlphaShortcuts(): string[];
+    function getAdditionalShortcuts(type: string): string[];
+    function getBindedShortcuts(components: any[], input: any): any[];
+    function getAvailableShortcuts(form: { components: any[] } | any, component: { type: any } | any): string[];
+  }
+}