@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/SmartScriptStore.ts

@@ -0,0 +1,492 @@
+import { Action } from 'redux';
+import {
+  updateOptionAction,
+  updateVariableAction,
+} from '../redux/actions/inputs';
+import {
+  updateOptionMetaAction,
+  updateVariableMetaAction,
+} from '../redux/actions/references';
+import {
+  updateSmartscriptOptionHiddenAction,
+  updateSmartscriptVariableHiddenAction,
+} from '../redux/actions/smartscript';
+import { ActionsType } from '../types/Actions.type';
+import { StateType } from '../types/State.type';
+
+export type CallbackType = () => void;
+
+export class SmartScriptStore {
+  static hooks: {
+    variables: Record<string, CallbackType[]>;
+    options: Record<string, CallbackType[]>;
+    init?: CallbackType[];
+    load?: CallbackType[];
+  } = {
+    options: {},
+    variables: {},
+  };
+
+  static actionsQueue: Action[] = [];
+
+  static inputs: StateType.Inputs = {
+    options: {},
+    variables: {},
+  };
+
+  /**
+   * Return actions queue and flush it
+   */
+  static grabActions() {
+    const actions = [...SmartScriptStore.actionsQueue];
+    SmartScriptStore.actionsQueue = [];
+    return actions;
+  }
+
+  static get triggers() {
+    const triggers: StateType.SmartScript['triggers'] = {
+      options: [],
+      variables: [],
+    };
+
+    Object.keys(SmartScriptStore.hooks.options).forEach((strId) => {
+      const id = parseInt(strId, 10);
+      triggers.options.push(id);
+    });
+
+    Object.keys(SmartScriptStore.hooks.variables).forEach((strId) => {
+      const id = parseInt(strId, 10);
+      triggers.variables.push(id);
+    });
+
+    return triggers;
+  }
+
+  /**
+   * Return option's input
+   * @param id
+   * @param index
+   */
+  static getOptionInput(id: number, index = 0) {
+    return SmartScriptStore.inputs.options[id][index];
+  }
+
+  /**
+   * Return all option inputs
+   * @param id
+   */
+  static getOptionAllInput(id: number) {
+    return SmartScriptStore.inputs.options[id];
+  }
+
+  /**
+   * Return variable's input
+   * @param id
+   * @param index
+   */
+  static getVariableInput(id: number, index = 0) {
+    const value = SmartScriptStore.inputs.variables[id][index];
+
+    // If value is a string but contains a number we parse it
+    if (
+      typeof value === 'string' &&
+      // eslint-disable-next-line no-restricted-globals
+      !isNaN(value.replace(',', '.') as any) &&
+      value.trim().length > 0
+    ) {
+      const result =
+        value.replace(',', '.').indexOf('.') > -1
+          ? parseFloat(value)
+          : parseInt(value, 10);
+      return result;
+    }
+
+    return value;
+  }
+
+  /**
+   * Return all variable inputs
+   * @param id
+   */
+  static getVariableAllInput(id: number) {
+    let values: (string | number)[] = [];
+
+    if (Array.isArray(SmartScriptStore.inputs.variables[id])) {
+      values = SmartScriptStore.inputs.variables[id].map((value) => {
+        // If value is a string but contains a number we parse it
+        if (
+          typeof value === 'string' &&
+          // eslint-disable-next-line no-restricted-globals
+          !isNaN(value.replace(',', '.') as any) &&
+          value.trim().length > 0
+        ) {
+          const result =
+            value.replace(',', '.').indexOf('.') > -1
+              ? parseFloat(value)
+              : parseInt(value, 10);
+          return result;
+        }
+
+        return value;
+      });
+    }
+
+    return values;
+  }
+
+  /**
+   * Adds callback to trigger change
+   * @param inputType
+   * @param id
+   * @param callback
+   */
+  static onChange(
+    inputType: 'option' | 'variable',
+    id: number | number[],
+    callback: CallbackType
+  ) {
+    const hooks =
+      SmartScriptStore.hooks[inputType === 'option' ? 'options' : 'variables'];
+
+    if (Array.isArray(id)) {
+      id.forEach((_id) => {
+        hooks[_id] = [...(hooks[_id] || []), callback];
+      });
+    } else {
+      hooks[id] = [...(hooks[id] || []), callback];
+    }
+  }
+
+  /**
+   * Add on init listener
+   * @param callback
+   */
+  static onInit(callback: CallbackType) {
+    if (typeof SmartScriptStore.hooks.init === 'undefined')
+      SmartScriptStore.hooks.init = [];
+    SmartScriptStore.hooks.init.push(callback);
+  }
+
+  /**
+   * Executes onInit callbacks
+   * @param callback
+   */
+  static execOnInit() {
+    try {
+      if (Array.isArray(SmartScriptStore.hooks.init)) {
+        SmartScriptStore.hooks.init.forEach((_cb) => {
+          _cb();
+        });
+      }
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error('SmartScript (onInit) error: ', e.message);
+    }
+  }
+
+  /**
+   * Add on load listener
+   * @param callback
+   */
+  static onLoad(callback: CallbackType) {
+    try {
+      if (typeof SmartScriptStore.hooks.load === 'undefined')
+        SmartScriptStore.hooks.load = [];
+      SmartScriptStore.hooks.load.push(callback);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error('SmartScript (onLoad) error: ', e.message);
+    }
+  }
+
+  /**
+   * Executes onLoad callbacks
+   * @param callback
+   */
+  static execOnLoad() {
+    if (Array.isArray(SmartScriptStore.hooks.load)) {
+      SmartScriptStore.hooks.load.forEach((_cb) => {
+        _cb();
+      });
+    }
+  }
+
+  /**
+   * Option's change listener
+   * @param id
+   * @param callback
+   */
+  static onOptionChange(id: number | number[], callback: CallbackType) {
+    return SmartScriptStore.onChange('option', id, callback);
+  }
+
+  /**
+   * Variable's change listener
+   * @param id
+   * @param callback
+   */
+  static onVariableChange(id: number | number[], callback: CallbackType) {
+    return SmartScriptStore.onChange('variable', id, callback);
+  }
+
+  static updateVariableInput = (
+    id: number,
+    value: string | number,
+    index = 0
+  ) => {
+    // Making sure variable exists
+    if (
+      !Object.prototype.hasOwnProperty.call(
+        SmartScriptStore.inputs.variables,
+        id
+      )
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to update meta for undefined variable ${id}`
+      );
+      return;
+    }
+
+    if (SmartScriptStore.inputs.variables[id]?.[index] !== value) {
+      if (typeof SmartScriptStore.inputs.variables[id] === 'undefined')
+        SmartScriptStore.inputs.variables[id] = [];
+      SmartScriptStore.inputs.variables[id][index] = value;
+      SmartScriptStore.actionsQueue.push(
+        updateVariableAction(id, value, index)
+      );
+    }
+  };
+
+  static updateOptionInput = (id: number, value: boolean, index = 0) => {
+    // Making sure option exists
+    if (
+      !Object.prototype.hasOwnProperty.call(SmartScriptStore.inputs.options, id)
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to update input for undefined option ${id}`
+      );
+      return;
+    }
+
+    if (SmartScriptStore.inputs?.options[id]?.[index] !== value) {
+      if (typeof SmartScriptStore.inputs.options[id] === 'undefined')
+        SmartScriptStore.inputs.options[id] = [];
+      SmartScriptStore.inputs.options[id][index] = value;
+      SmartScriptStore.actionsQueue.push(updateOptionAction(id, value, index));
+    }
+  };
+
+  /**
+   * Updates variable's meta
+   * @param id
+   * @param _meta
+   */
+  static updateVariableMeta = (
+    id: number,
+    _meta: ActionsType.References.updateVariableMeta['meta']
+  ) => {
+    // Making sure variable exists
+    if (
+      !Object.prototype.hasOwnProperty.call(
+        SmartScriptStore.inputs.variables,
+        id
+      )
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to update meta for undefined variable ${id}`
+      );
+      return;
+    }
+
+    const meta = { ..._meta };
+
+    // Deleting all banned meta params
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.id !== 'undefined') delete meta.id;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.type !== 'undefined') delete meta.type;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.conditions !== 'undefined') delete meta.conditions;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.prefillings !== 'undefined') delete meta.prefillings;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.validator?.conditions !== 'undefined')
+      // @ts-expect-error: Meta should not have banned prop
+      delete meta.validator.conditions;
+
+    SmartScriptStore.actionsQueue.push(updateVariableMetaAction(id, meta));
+  };
+
+  /**
+   * Updates option's meta
+   * @param id
+   * @param _meta
+   */
+  static updateOptionMeta = (
+    id: number,
+    _meta: ActionsType.References.updateOptionMeta['meta']
+  ) => {
+    // Making sure option exists
+    if (
+      !Object.prototype.hasOwnProperty.call(SmartScriptStore.inputs.options, id)
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to update meta for undefined option ${id}`
+      );
+      return;
+    }
+
+    const meta = { ..._meta };
+
+    // Deleting all banned meta params
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.id !== 'undefined') delete meta.id;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.type !== 'undefined') delete meta.type;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.conditions !== 'undefined') delete meta.conditions;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.repeatOption !== 'undefined') delete meta.repeatOption;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.validator?.conditions !== 'undefined')
+      // @ts-expect-error: Meta should not have banned prop
+      delete meta.validator.conditions;
+    // @ts-expect-error: Meta should not have banned prop
+    if (typeof meta.multiple?.enabled !== 'undefined')
+      // @ts-expect-error: Meta should not have banned prop
+      delete meta.multiple.enabled;
+
+    SmartScriptStore.actionsQueue.push(updateOptionMetaAction(id, meta));
+  };
+
+  /**
+   * Hides option
+   * @param id
+   * @param index Will hide all options if not given
+   */
+  static hideOption = (id: number, index?: number) => {
+    // Making sure option exists
+    if (
+      !Object.prototype.hasOwnProperty.call(SmartScriptStore.inputs.options, id)
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(`SmartScript error: trying to hide undefined option ${id}`);
+      return;
+    }
+
+    if (typeof index === 'undefined') {
+      SmartScriptStore.updateOptionMeta(id, { hidden: true });
+      SmartScriptStore.inputs.options[id].forEach((_, _index) => {
+        SmartScriptStore.actionsQueue.push(
+          updateSmartscriptOptionHiddenAction(id, _index, true)
+        );
+      });
+    } else {
+      SmartScriptStore.actionsQueue.push(
+        updateSmartscriptOptionHiddenAction(id, index, true)
+      );
+    }
+  };
+
+  /**
+   * Displays option
+   * @param id
+   * @param index Will display all options if not given
+   */
+  static displayOption = (id: number, index?: number) => {
+    // Making sure option exists
+    if (
+      !Object.prototype.hasOwnProperty.call(SmartScriptStore.inputs.options, id)
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to display undefined option ${id}`
+      );
+      return;
+    }
+    if (typeof index === 'undefined') {
+      SmartScriptStore.updateOptionMeta(id, { hidden: false });
+      SmartScriptStore.inputs.options[id].forEach((_, _index) => {
+        SmartScriptStore.actionsQueue.push(
+          updateSmartscriptOptionHiddenAction(id, _index, false)
+        );
+      });
+    } else {
+      SmartScriptStore.actionsQueue.push(
+        updateSmartscriptOptionHiddenAction(id, index, false)
+      );
+    }
+  };
+
+  /**
+   * Hides variable
+   * @param id
+   * @param index Will hide all variables if not given
+   */
+  static hideVariable = (id: number, index?: number) => {
+    // Making sure variable exists
+    if (
+      !Object.prototype.hasOwnProperty.call(
+        SmartScriptStore.inputs.variables,
+        id
+      )
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to hide undefined variable ${id}`
+      );
+      return;
+    }
+
+    if (typeof index === 'undefined') {
+      SmartScriptStore.updateVariableMeta(id, { hidden: true });
+      SmartScriptStore.inputs.variables[id].forEach((_, _index) => {
+        SmartScriptStore.actionsQueue.push(
+          updateSmartscriptVariableHiddenAction(id, _index, true)
+        );
+      });
+    } else {
+      SmartScriptStore.actionsQueue.push(
+        updateSmartscriptVariableHiddenAction(id, index, true)
+      );
+    }
+  };
+
+  /**
+   * Displays variable
+   * @param id
+   * @param index Will display all variables if not given
+   */
+  static displayVariable = (id: number, index?: number) => {
+    // Making sure variable exists
+    if (
+      !Object.prototype.hasOwnProperty.call(
+        SmartScriptStore.inputs.variables,
+        id
+      )
+    ) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `SmartScript error: trying to display undefined variable ${id}`
+      );
+      return;
+    }
+
+    if (typeof index === 'undefined') {
+      SmartScriptStore.updateVariableMeta(id, { hidden: false });
+      SmartScriptStore.inputs.variables[id].forEach((_, _index) => {
+        SmartScriptStore.actionsQueue.push(
+          updateSmartscriptVariableHiddenAction(id, _index, false)
+        );
+      });
+    } else {
+      SmartScriptStore.actionsQueue.push(
+        updateSmartscriptVariableHiddenAction(id, index, false)
+      );
+    }
+  };
+}

package/src/libs/index.ts

@@ -0,0 +1,12 @@
+export * from './ConditionsInitiator';
+export * from './ConditionsRunner';
+export * from './DocumentsOutputs';
+export * from './EvalVariable';
+export * from './EventsTracking';
+export * from './Extracts';
+export * from './InputsInitiator';
+export * from './NumAuto';
+export * from './OvcConverter';
+export * from './PathReader';
+export * from './SectionValidity';
+export * from './SmartScriptStore';