@legalplace/wizardx-core 0.0.1-alpha.0

package/src/componentsConnectors/connectBox.tsx

@@ -0,0 +1,70 @@
+import type { OptionV3 } from '@legalplace/models-v3-types';
+import {
+  componentConnector,
+  ConnectorStateToProps,
+} from './connector/componentConnector';
+import {
+  getRelatedVariablesValues,
+  parseContentWithVariables,
+} from '../helpers/outputsParsing';
+
+export type ConnectBoxOwnProps = {
+  id: number;
+  index: number;
+};
+export type ConnectBoxMapProps = {
+  type: string;
+  content: string;
+  box: OptionV3['meta']['box'];
+  condition?: boolean;
+  options: number[];
+  tags?: string[];
+};
+
+const stateToProps: ConnectorStateToProps<
+  ConnectBoxOwnProps,
+  ConnectBoxMapProps
+> = (selectors) => (state, ownProps) => {
+  // Destructring ownProps
+  const { id, index } = ownProps;
+
+  // Getting option reference
+  const option = selectors.selectOptionReference(id);
+
+  // Getting box reference
+  const boxReference = selectors.selectBoxReference(id);
+
+  // Getting outputs variables
+  const variables = getRelatedVariablesValues(
+    id,
+    index,
+    boxReference.variables
+  );
+
+  // Parsing content
+  const condition = selectors.selectOptionConditionValue(id, index);
+  const content =
+    condition === false
+      ? ''
+      : parseContentWithVariables(boxReference.raw, id, index, variables);
+
+  // Destructuring needed params
+  const { options, meta } = option;
+  const { tags, type, box } = meta;
+
+  return {
+    id,
+    index,
+    type,
+    content,
+    condition,
+    box,
+    tags,
+    options,
+  };
+};
+
+export const connectBox = componentConnector({
+  componentName: 'Box',
+  stateToProps,
+});

package/src/componentsConnectors/connectDocument.test.tsx

@@ -0,0 +1,108 @@
+import * as fs from 'fs';
+import React from 'react';
+import renderer from 'react-test-renderer';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { getStore, createAppStore } from '../redux/store';
+import { initReferencesAction } from '../redux/actions/references';
+import { ConditionsInitiator } from '../libs/ConditionsInitiator';
+import { initConditionsAction } from '../redux/actions/conditions';
+import { IntputsInitiator } from '../libs/InputsInitiator';
+import { initOptionAction, initVariableAction } from '../redux/actions/inputs';
+
+const ovc = {
+  options: { 1: [true], 2: [true, true], 3: [true, false], 4: [false, true] },
+  variables: {
+    1: ['My VAR1'],
+    2: ['My VAR 2 1st', 'My VAR 2 2nd'],
+    3: ['My VAR 3 1st', 'My VAR 3 2nd'],
+  },
+};
+
+describe('connectDocument test suit', () => {
+  let store: any;
+  let connectDocument: any;
+  beforeEach(async () => {
+    createAppStore('memory');
+    const model = JSON.parse(
+      fs.readFileSync(
+        './src/misc/test_models/connectDocumen.testmodel.json',
+        'utf8'
+      )
+    );
+    // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+    connectDocument = await require('./connectDocument').connectDocument;
+    const references = new ReferencesParser(model).getReferences();
+    const inputs = new IntputsInitiator(references, ovc).getInputs();
+    const conditions = new ConditionsInitiator(
+      references,
+      inputs
+    ).getConditions();
+    store = getStore();
+    store.dispatch(initReferencesAction(references));
+    store.dispatch(initConditionsAction(conditions));
+
+    /**
+     * Initiating inputs
+     */
+
+    // Options
+    const optionsIds = Object.keys(inputs.options);
+    for (let i = 0; i < optionsIds.length; i += 1) {
+      const optionId = optionsIds[i];
+      const values = inputs.options[optionId];
+      store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+    }
+
+    // Variables
+    const variablesIds = Object.keys(inputs.variables);
+    for (let i = 0; i < variablesIds.length; i += 1) {
+      const variableId = variablesIds[i];
+      const values = inputs.variables[variableId];
+      store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+    }
+  });
+
+  it('Should retrun props properly', async () => {
+    const ConnectDocument = connectDocument((props: any) => {
+      return <h1>{props.document}</h1>;
+    });
+    const component = renderer.create(
+      <ConnectDocument store={store} document="main" />
+    );
+
+    // @ts-ignore
+    const { props } = component.toTree().rendered;
+
+    const { document, outputs } = props;
+
+    expect({ document, outputs }).toStrictEqual({
+      document: 'main',
+      outputs: {
+        'output-5-0':
+          '<p>Should output <strong>Variable 1</strong>&nbsp;My VAR1</p>\n',
+      },
+    });
+  });
+
+  it('Should use main as default', () => {
+    const ConnectDocument = connectDocument((props: any) => {
+      return <h1>{props.document}</h1>;
+    });
+    const component = renderer.create(
+      <ConnectDocument store={store} document="default" />
+    );
+
+    // @ts-ignore
+    const { props } = component.toTree().rendered;
+
+    const { document, outputs } = props;
+
+    expect({ document, outputs }).toStrictEqual({
+      document: 'main',
+      outputs: {
+        'output-5-0':
+          '<p>Should output <strong>Variable 1</strong>&nbsp;My VAR1</p>\n',
+      },
+    });
+  });
+});

package/src/componentsConnectors/connectDocument.tsx

@@ -0,0 +1,64 @@
+import {
+  componentConnector,
+  ConnectorStateToProps,
+} from './connector/componentConnector';
+import { NumAuto } from '../libs/NumAuto';
+import { DocumentsOutputs } from '../libs/DocumentsOutputs';
+import { selectAllSectionsReferences } from '../redux/selectors/references';
+
+export type ConnectDocumentOwnProps = { document: string };
+export type ConnectDocumentMapProps = {
+  document: string;
+  outputs: Record<string, string>;
+};
+
+const stateToProps: ConnectorStateToProps<
+  ConnectDocumentOwnProps,
+  ConnectDocumentMapProps
+> = (selectors) => (state, ownProps) => {
+  const {
+    selectOptionConditionValue,
+    selectSectionConditionValue,
+    selectOptionInput,
+    selectVariableInput,
+    selectOptionReference,
+    selectOutputReference,
+    selectVariableReference,
+    selectSectionReference,
+  } = selectors;
+
+  // Getting current document
+  const document = ownProps.document === 'default' ? 'main' : ownProps.document;
+
+  const documentOutputs = new DocumentsOutputs(
+    {
+      optionConditions: (id: number, index: number) =>
+        selectOptionConditionValue(id, index),
+      sectionConditions: (id: number, doc: string) =>
+        selectSectionConditionValue(id, doc),
+      optionInputs: (id: number) => selectOptionInput(id),
+      variablesInputs: (id: number) => selectVariableInput(id),
+      optionReference: (id: number) => selectOptionReference(id),
+      outputReference: (id: number) => selectOutputReference(id),
+      variableReference: (id: number) => selectVariableReference(id),
+      sectionReference: (id: number) => selectSectionReference(id),
+      documentSections: (doc: string) => selectAllSectionsReferences(doc),
+    },
+    document
+  );
+
+  const outputs = documentOutputs.getOutputs();
+
+  // Reseting autonums
+  NumAuto.resetNums();
+
+  return {
+    document,
+    outputs,
+  };
+};
+
+export const connectDocument = componentConnector({
+  componentName: 'Document',
+  stateToProps,
+});

package/src/componentsConnectors/connectHeader.tsx

@@ -0,0 +1,21 @@
+import {
+  componentConnector,
+  ConnectorStateToProps,
+} from './connector/componentConnector';
+
+export type ConnectHeaderOwnProps = { isPreviewDisplayed: boolean };
+export type ConnectHeaderMapProps = {
+  hasValidAuthToken: boolean;
+};
+
+const stateToProps: ConnectorStateToProps<
+  ConnectHeaderOwnProps,
+  ConnectHeaderMapProps
+> = (selectors) => () => ({
+  hasValidAuthToken: selectors.selectUserValidToken(),
+});
+
+export const connectHeader = componentConnector({
+  componentName: 'AppHeader',
+  stateToProps,
+});

package/src/componentsConnectors/connectMetaTitle.test.tsx

@@ -0,0 +1,40 @@
+import React from 'react';
+import renderer from 'react-test-renderer';
+import { StateType } from '../types/State.type';
+import { getStore, createAppStore } from '../redux/store';
+import { initMetaAction } from '../redux/actions/app';
+
+const meta: StateType.App.Meta = {
+  title: 'My Test Document',
+  id: 132,
+  prefix: '',
+  permalink: 'my-test-document',
+  fetchStatus: 'succeeded',
+  modelVersion: 1,
+  productType: 'demarche',
+};
+describe('connectMetaTitle test suit', () => {
+  let store: any;
+  let connectMetaTitle: any;
+  beforeEach(() => {
+    createAppStore('memory');
+    store = getStore();
+    store.dispatch(initMetaAction(meta));
+    // eslint-disable-next-line global-require
+    connectMetaTitle = require('./connectMetaTitle').connectMetaTitle;
+  });
+
+  it('Should retrun props properly', () => {
+    const ConnectMetaTitle = connectMetaTitle((props: any) => {
+      return <h1>{props.title}</h1>;
+    });
+    const component = renderer.create(<ConnectMetaTitle store={store} />);
+
+    // @ts-ignore
+    const { props } = component.toTree().rendered;
+
+    const { title } = props;
+
+    expect({ title }).toStrictEqual({ title: 'My Test Document' });
+  });
+});

package/src/componentsConnectors/connectMetaTitle.tsx

@@ -0,0 +1,8 @@
+import { componentConnector } from './connector/componentConnector';
+
+export const connectMetaTitle = componentConnector({
+  componentName: 'MetaTitle',
+  stateToProps: (selectors) => () => ({
+    title: selectors.selectDocumentTitle(),
+  }),
+});

package/src/componentsConnectors/connectOption.tsx

@@ -0,0 +1,222 @@
+import type { OptionV3 } from '@legalplace/models-v3-types';
+import {
+  parseOptionLabel,
+  parseRawWithVariables,
+} from '../helpers/outputsParsing';
+import {
+  componentConnector,
+  ConnectorStateToProps,
+  ConnectorDispatchProps,
+  ConnectorMapSelectors,
+} from './connector/componentConnector';
+import { isStepAvailable } from '../redux/selectors/app';
+
+export type ConnectOptionOwnProps = {
+  id: number;
+  index: number;
+  isLast?: boolean;
+  isMultiple?: boolean;
+  hasMany?: boolean;
+};
+export type ConnectOptionMapProps = {
+  label: string;
+  type: string;
+  value: boolean;
+  condition?: boolean;
+  validator?: boolean;
+  mandatoryValidated: boolean;
+  mandatoryIgnore: boolean;
+  display: boolean;
+  meta: OptionV3['meta'];
+  selectedRadioChild: number;
+  childOptions: number[];
+  childVariables: number[];
+};
+export type ConnectOptionDispatchProps = {
+  updateOption: (value: boolean, id?: number, index?: number) => void;
+  addMultipleOccurency: () => void;
+  deleteMultipleOccurency: () => void;
+};
+
+/**
+ * canOptionDisplay
+ * ----------------
+ * This helper function checks whether an option
+ * can be displayed. It currently handle this cases:
+ * - Checks stepTwo options
+ * - Checks special grants options
+ * @param id Option's ID
+ * @param selectors StateToProps selectors
+ * @returns (boolean)
+ */
+const canOptionDisplay = (
+  id: number,
+  index: number,
+  selectors: ConnectorMapSelectors
+) => {
+  const option = selectors.selectOptionReference(id);
+
+  // Checking steps
+  let display = isStepAvailable(option.meta.step);
+
+  // Checking if option is hidden by model or smartscript on all indexes
+  display = display && !(option.meta.hidden === true);
+
+  // Checking if option's index is hidden by smartscript
+  display =
+    display && !selectors.selectIsSmartscriptOptionIndexHidden(id, index);
+
+  // Checking if current user is granted access to this option
+  const grantLevel =
+    typeof option.meta.grantLevel === 'string'
+      ? option.meta.grantLevel
+      : 'GUEST';
+  display = display && selectors.isLevelAccessibleForUser(grantLevel);
+
+  // Returning result
+  return display;
+};
+
+/**
+ * selectedRadioChilds
+ * -------------------
+ * This helper functions returns the selected
+ * radio children of a given option at a specific
+ * index if there's any
+ * @param id Option's id
+ * @param index Option's index
+ * @param selectors StateToProps selectors
+ */
+const selectedRadioChilds = (
+  id: number,
+  index: number,
+  selectors: ConnectorMapSelectors
+) => {
+  const option = selectors.selectOptionReference(id);
+  return option.options.filter((childId) => {
+    const childReference = selectors.selectOptionReference(childId);
+
+    return (
+      childReference.meta.type === 'radio' &&
+      selectors.selectOptionInputByIndex(childId, index)
+    );
+  })[0];
+};
+
+/**
+ * stateToProps
+ * ------------
+ * State to props function maps state to connected
+ * component's props
+ * @param selectors StateToProps selectors
+ */
+const stateToProps: ConnectorStateToProps<
+  ConnectOptionOwnProps,
+  ConnectOptionMapProps
+> = (selectors) => (state, ownProps) => {
+  const { id, index } = ownProps;
+  const option = selectors.selectOptionReference(id);
+
+  // Checking if option can display (this is not related to conditions)
+  const display = canOptionDisplay(id, index, selectors);
+
+  // Getting option's selected radio children
+  const selectedRadioChild = selectedRadioChilds(id, index, selectors);
+
+  // Getting & parsing label (if needed)
+  const label = parseOptionLabel(id, index);
+
+  // Getting value
+  let value = selectors.selectOptionInputByIndex(id, index);
+  value = value || false;
+
+  // Getting condition
+  const condition = selectors.selectOptionConditionValue(id, index);
+
+  // Getting valudator
+  const validator = selectors.selectOptionValidatorConditionValue(id, index);
+
+  // Getting mandatoryValidated
+  const mandatoryValidated = selectors.selectMandatoryOptionByIndex(id, index);
+
+  // Getting MandartoryIgnore
+  const mandatoryIgnore = selectors.selectMandatoryIgnore();
+
+  // Extracting props from option reference
+  const { meta, options: childOptions, variables: childVariables } = option;
+
+  // Parsing helper's variables
+  const helper = meta.helper
+    ? parseRawWithVariables(meta.helper, undefined, '________________')
+    : undefined;
+
+  // Parsing warning's variables
+  const warning = meta.warning
+    ? parseRawWithVariables(meta.warning, undefined, '________________')
+    : undefined;
+
+  const { type } = meta;
+  return {
+    label,
+    type,
+    meta: {
+      ...meta,
+      warning,
+      helper,
+    },
+    value,
+    mandatoryValidated,
+    mandatoryIgnore,
+    condition,
+    validator,
+    display,
+    selectedRadioChild,
+    childOptions,
+    childVariables,
+  };
+};
+
+/**
+ * dispatchToProps
+ * ------------
+ * Dispatch to props function maps dispatch to connected
+ * component's props
+ * @param actions DispatchToProps actions
+ */
+const dispatchToProps: ConnectorDispatchProps<
+  ConnectOptionOwnProps,
+  ConnectOptionDispatchProps
+> = (actions) => (dispatch, ownProps) => ({
+  updateOption: (
+    value: boolean,
+    id: number = ownProps.id,
+    index: number = ownProps.index
+  ) => dispatch(actions.updateOptionAction(id, value, index)),
+  addMultipleOccurency: () => {
+    dispatch(actions.addMultipleOccurencyAction(ownProps.id));
+  },
+  deleteMultipleOccurency: () => {
+    dispatch(
+      actions.deleteMultipleOccurencyAction(ownProps.id, ownProps.index)
+    );
+  },
+});
+
+/**
+ * Creating our component connector
+ */
+export const connectOption = componentConnector({
+  componentName: 'Option',
+  stateToProps,
+  dispatchToProps,
+  additionnalHooks: (props, hookType) => {
+    const { tags, type } = props.meta;
+    const hooks: string[] = [`${hookType}OptionOfType(${type})`];
+    if (Array.isArray(tags)) {
+      tags.forEach((currentTag) => {
+        hooks.push(`${hookType}Tag{${currentTag}}`);
+      });
+    }
+    return hooks;
+  },
+});

package/src/componentsConnectors/connectPagination.tsx

@@ -0,0 +1,104 @@
+import {
+  componentConnector,
+  ConnectorStateToProps,
+  ConnectorDispatchProps,
+} from './connector/componentConnector';
+
+export type ConnectPaginationOwnProps = {};
+export type ConnectPaginationMapProps = {
+  totalPages: number;
+  isFirstPage: boolean;
+  isLastPage: boolean;
+  isLastWizardPage: boolean;
+  isUserAuthenticated: boolean;
+  isCurrentSectionMandatoryValidated: boolean;
+  mandatoryIgnore: boolean;
+  firstUnfinishedSectionId: number;
+  currentSection: number;
+  currentPage: number;
+};
+export type ConnectPaginationDispatchProps = {
+  goNextPage: () => void;
+  goPreviousPage: () => void;
+};
+
+/**
+ * stateToProps
+ * ------------
+ * State to props function maps state to connected
+ * component's props
+ * @param selectors StateToProps selectors
+ */
+const stateToProps: ConnectorStateToProps<
+  ConnectPaginationOwnProps,
+  ConnectPaginationMapProps
+> = (selectors) => () => {
+  const {
+    selectIsFirstPage,
+    selectCurrentPage,
+    selectIsLastPage,
+    selectIsLastWizardPage,
+    selectAvailableSections,
+    selectUserStatus,
+    selectMandatorySection,
+    selectCurrentSectionId,
+    selectFirstUnfinishedSectionId,
+    selectMandatoryIgnore,
+  } = selectors;
+  const isFirstPage = selectIsFirstPage();
+  const currentPage = selectCurrentPage();
+  const isLastPage = selectIsLastPage();
+  const isLastWizardPage = selectIsLastWizardPage();
+  const totalPages = selectAvailableSections().length;
+  const userStatus = selectUserStatus();
+
+  const currentSection = selectCurrentSectionId();
+
+  // Getting MandatoryIgnore
+  const mandatoryIgnore = selectMandatoryIgnore();
+
+  const isCurrentSectionMandatoryValidated =
+    selectMandatorySection(currentSection);
+
+  const firstUnfinishedSectionId =
+    selectFirstUnfinishedSectionId(currentSection);
+
+  return {
+    isFirstPage,
+    isLastPage,
+    totalPages,
+    isLastWizardPage,
+    isCurrentSectionMandatoryValidated,
+    firstUnfinishedSectionId,
+    currentSection,
+    mandatoryIgnore,
+    isUserAuthenticated: userStatus === 'authenticated',
+    currentPage,
+  };
+};
+
+/**
+ * dispatchToProps
+ * ------------
+ * Dispatch to props function maps dispatch to connected
+ * component's props
+ * @param actions DispatchToProps actions
+ */
+const dispatchToProps: ConnectorDispatchProps<
+  ConnectPaginationOwnProps,
+  ConnectPaginationDispatchProps
+> = (actions) => (dispatch) => {
+  return {
+    goNextPage: () => dispatch(actions.goNextPageAction()),
+    goPreviousPage: () => dispatch(actions.goPreviousPageAction()),
+  };
+};
+
+/**
+ * Creating our component connector
+ */
+export const connectPagination = componentConnector({
+  componentName: 'Pagination',
+  stateToProps,
+  dispatchToProps,
+});

package/src/componentsConnectors/connectPreview.tsx

@@ -0,0 +1,5 @@
+import { componentConnector } from './connector/componentConnector';
+
+export const connectPreview = componentConnector({
+  componentName: 'PreviewComponent',
+});

package/src/componentsConnectors/connectProgress.tsx

@@ -0,0 +1,59 @@
+import {
+  componentConnector,
+  ConnectorStateToProps,
+} from './connector/componentConnector';
+
+export type ConnectPreviewOwnProps = {
+  id?: number;
+};
+export type ConnectPreviewMapProps = {
+  currentSectionTitle: string;
+  currentSectionId: number;
+  currentSection: number;
+  currentPage: number;
+  greatestPage: number;
+  totalPages: number;
+};
+
+/**
+ * stateToProps
+ * ------------
+ * State to props function maps state to connected
+ * component's props
+ * @param selectors StateToProps selectors
+ */
+const stateToProps: ConnectorStateToProps<
+  ConnectPreviewOwnProps,
+  ConnectPreviewMapProps
+> = (selectors) => (state, ownProps) => {
+  const {
+    selectCurrentSectionId,
+    selectAvailableSections,
+    selectSectionReference,
+    selectCurrentPage,
+  } = selectors;
+
+  const currentSectionId =
+    typeof ownProps.id === 'number' ? ownProps.id : selectCurrentSectionId();
+  const sectionReference = selectSectionReference(currentSectionId);
+  const currentSectionTitle = sectionReference.label;
+  const availableSections = selectAvailableSections();
+  const totalPages = availableSections.length;
+
+  return {
+    currentSectionTitle,
+    currentSectionId,
+    totalPages,
+    currentSection: availableSections.indexOf(currentSectionId) + 1,
+    currentPage: selectCurrentPage(),
+    greatestPage: state.app.pagination.greatestPage,
+  };
+};
+
+/**
+ * Creating our component connector
+ */
+export const connectProgress = componentConnector({
+  componentName: 'Progress',
+  stateToProps,
+});