@ea-lab/reactive-json 0.0.19 → 0.0.21

package/lib/engine/Actions.jsx

@@ -1,392 +0,0 @@
-import {useContext} from "react";
-import GlobalDataContext from "./GlobalDataContext";
-import TemplateContext from "./TemplateContext";
-import {evaluateTemplateValue, isTemplateValue} from "./TemplateSystem";
-
-import HashChangeListener from "../component/action/HashChangeListener";
-import Hide from "../component/action/Hide";
-import MessageListener from "../component/action/MessageListener";
-import Popover from "../component/action/Popover";
-import ReactOnEvent, {reactionFunctions} from "../component/action/ReactOnEvent";
-import Redirect from "../component/action/Redirect";
-import Tooltip from "../component/action/Tooltip";
-import VisuallyHide from "../component/action/VisuallyHide";
-import {isEqual} from "lodash";
-import JSONPath from "jsonpath";
-
-/**
- * Contains the list of available actions in config.
- * @type {{}}
- */
-const actionsToEvaluate = {
-    hide: Hide,
-    popover: Popover,
-    redirect: Redirect,
-    tooltip: Tooltip,
-    visuallyHide: VisuallyHide,
-};
-
-/**
- * Capitalizes the first letter.
- *
- * @param str
- * @returns {string}
- */
-const capitalizeFirstLetter = (str) => str && str.charAt(0).toUpperCase() + str.slice(1);
-
-/**
- * Checks whether the conditions are fulfilled.
- * @param {{andConditions, containedBy, containedByNot, contains, containsNot, is, isNot, orConditions, when, whenDataCountOf, ">", "<", ">=", "<=", compareAsDates}} condition
- * @param {object} templateContexts
- * @param {Map} additionalConditionHandlers
- * @returns {*}
- */
-export const isValid = (condition, templateContexts, additionalConditionHandlers) => {
-    const {globalDataContext, templateContext} = templateContexts;
-
-    if (Array.isArray(condition.andConditions)) {
-        return condition.andConditions.reduce(
-            (acc, cur) => {
-                // All sub conditions must be true.
-                return acc && isValid(cur, templateContexts, additionalConditionHandlers);
-            },
-            true
-        );
-    }
-
-    if (Array.isArray(condition.orConditions)) {
-        const orConditions = condition.orConditions;
-
-        for (const condition of orConditions) {
-            if (isValid(condition, templateContexts, additionalConditionHandlers)) {
-                // A single condition is enough to validate.
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    if (condition.when !== undefined && !isTemplateValue(condition.when)) {
-        return false;
-    }
-
-    const evaluateTemplateValueLocal = (toEvaluate) => {
-        return evaluateTemplateValue({
-            globalDataContext: globalDataContext,
-            templateContext: templateContext,
-            valueToEvaluate: toEvaluate,
-        });
-    }
-
-    let valueToCompare;
-
-    if (condition.when === undefined && condition.hasOwnProperty("whenDataCountOf")) {
-        // Select where to count.
-        let countFinalTemplateData;
-
-        switch (condition.inContext) {
-            case "root":
-                countFinalTemplateData = globalDataContext.getRootContext().templateData;
-                break;
-
-            case "template":
-                countFinalTemplateData = templateContext.templateData;
-                break;
-
-            default:
-                countFinalTemplateData = globalDataContext.templateData;
-                break;
-        }
-
-        valueToCompare = JSONPath.query(countFinalTemplateData, condition.whenDataCountOf).length;
-    } else {
-        // Other code may inject additional condition handler which can return the value to compare.
-        valueToCompare = (() => {
-            if (additionalConditionHandlers) {
-                for (const [handlerId, additionalConditionHandler] of additionalConditionHandlers) {
-                    if (condition.hasOwnProperty(handlerId)) {
-                        // This additional condition handler will compute the value to compare.
-                        return additionalConditionHandler({
-                            condition,
-                            templateContexts,
-                            evaluateAgainstTemplates: (value) => {
-                                return evaluateTemplateValueLocal(value);
-                            }
-                        });
-                    }
-                }
-            }
-
-            // Compute using the usual method.
-            return evaluateTemplateValueLocal(condition.when);
-        })();
-    }
-
-    if (condition.hasOwnProperty("isEmpty")) {
-        const maybeInvert = val => condition.isEmpty === "not" ? !val : val;
-
-        if (valueToCompare === null) {
-            return maybeInvert(true);
-        }
-
-        switch (typeof valueToCompare) {
-            case "undefined":
-                return maybeInvert(true);
-
-            case "string":
-                return maybeInvert(valueToCompare.length === 0);
-
-            case "object":
-                return maybeInvert(Object.keys(valueToCompare).length === 0);
-
-            default:
-                return maybeInvert(!valueToCompare);
-        }
-    }
-
-    // This can be useful when two differently formatted dates must be compared.
-    const compareAsDates = condition.compareAsDates;
-
-    if (condition.hasOwnProperty("isNot")) {
-        return maybeDate(compareAsDates, valueToCompare) !== maybeDate(compareAsDates, evaluateTemplateValueLocal(condition.isNot));
-    }
-
-    if (condition.hasOwnProperty("is")) {
-        return maybeDate(compareAsDates, valueToCompare) === maybeDate(compareAsDates, evaluateTemplateValueLocal(condition.is));
-    }
-
-    if (condition.hasOwnProperty("containsNot") || condition.hasOwnProperty("contains")) {
-        // True if containsNot.
-        const invertedMode = condition.hasOwnProperty("containsNot");
-
-        const needleSource = invertedMode ? condition.containsNot : condition.contains;
-
-        const needle = maybeDate(compareAsDates, evaluateTemplateValueLocal(needleSource));
-
-        if (typeof valueToCompare === "string") {
-            // Check as a string. Do a case-insensitive check.
-            if (typeof needle !== "string") {
-                // The types do not match.
-                return invertedMode;
-            }
-
-            const result = valueToCompare.toLowerCase().indexOf(needle.toLowerCase()) !== -1;
-
-            return invertedMode ? !result : result;
-        } else {
-            for (const item of Object.values(valueToCompare)) {
-                if (isEqual(maybeDate(compareAsDates, item), needle)) {
-                    // The needle has been found. When in inverted mode (containsNot), return false.
-                    return !invertedMode;
-                }
-            }
-        }
-
-        // The needle has not been found. When in inverted mode (containsNot), return true.
-        return invertedMode;
-    }
-
-    if (condition.hasOwnProperty("containedByNot") || condition.hasOwnProperty("containedBy")) {
-        // True if containedByNot.
-        const invertedMode = condition.hasOwnProperty("containedByNot");
-
-        const needleSource = invertedMode ? condition.containedByNot : condition.containedBy;
-
-        const container = maybeDate(compareAsDates, evaluateTemplateValueLocal(needleSource));
-
-        if (typeof valueToCompare === "string") {
-            // Check as a string. Do a case-insensitive check.
-            if (typeof container !== "string") {
-                // The types do not match.
-                return invertedMode;
-            }
-
-            const result = container.toLowerCase().indexOf(valueToCompare.toLowerCase()) !== -1;
-
-            return invertedMode ? !result : result;
-        } else {
-            for (const item of Object.values(container)) {
-                if (isEqual(maybeDate(compareAsDates, item), valueToCompare)) {
-                    // The needle has been found. When in inverted mode (containsNot), return false.
-                    return !invertedMode;
-                }
-            }
-        }
-
-        // The needle has not been found. When in inverted mode (containsNot), return true.
-        return invertedMode;
-    }
-
-    if (condition.hasOwnProperty(">")) {
-        return maybeDate(compareAsDates, valueToCompare) > maybeDate(compareAsDates, evaluateTemplateValueLocal(condition[">"]));
-    }
-
-    if (condition.hasOwnProperty(">=")) {
-        return maybeDate(compareAsDates, valueToCompare) >= maybeDate(compareAsDates, evaluateTemplateValueLocal(condition[">="]));
-    }
-
-    if (condition.hasOwnProperty("<")) {
-        return maybeDate(compareAsDates, valueToCompare) < maybeDate(compareAsDates, evaluateTemplateValueLocal(condition["<"]));
-    }
-
-    if (condition.hasOwnProperty("<=")) {
-        return maybeDate(compareAsDates, valueToCompare) <= maybeDate(compareAsDates, evaluateTemplateValueLocal(condition["<="]));
-    }
-
-    // No condition means always valid.
-    return true;
-};
-
-/**
- * Gets the actions to execute for the current component.
- * @param {Array} actions
- * @param {object} templateContexts
- * @returns {*[]}
- */
-const getActionsToExecute = (actions, templateContexts) => {
-    const result = [];
-
-    let requiresReactionComponent = false;
-
-    const reactionFunctionProps = {};
-
-    if (!Array.isArray(actions)) {
-        // Not a supported actions structure.
-        // Dev note: we may also allow objects in the future, to allow specific overrides.
-        return result;
-    }
-
-    // The index is useful to build the data path for the components created by the actions.
-    // This is a requirement of the View components.
-    // Dev note: could it be like the components, where we can specify string keys,
-    // thus allowing objects in the actions definitions?
-    for (const [index, item] of actions.entries()) {
-        const what = item?.what ?? undefined;
-
-        if (!what) {
-            continue;
-        }
-
-        const Component = actionsToEvaluate[what];
-        let reactionFunction = undefined;
-
-        if (!Component) {
-            // This is not a component. Maybe it's a reaction function...
-            reactionFunction = reactionFunctions[what] ?? undefined;
-
-            if (!reactionFunction) {
-                // The component is unknown or not registered,
-                // and it's not a reaction function.
-                continue;
-            }
-
-            // This is a reaction function.
-            if (item.on === undefined) {
-                // Reaction functions are called only in response to events.
-                // Dev note: evaluate if we can execute reaction functions on component mount,
-                // with empty "on".
-                continue;
-            }
-
-            if (!isValid(item, templateContexts)) {
-                continue;
-            }
-
-            if (item.on === "message") {
-                // "message" has a special handling. It adds the special MessageListener action component.
-                // This is because the message event can only be listened to on the window object,
-                // so it adds event listeners on the window object (not the current component).
-                result.push({ActionComponent: MessageListener, actionProps: item, actionIndex: index});
-                continue;
-            }
-
-            if (item.on === "hashchange") {
-                // "hashchange" works in the same way than "message": it must be added on the window object.
-                result.push({ActionComponent: HashChangeListener, actionProps: item, actionIndex: index});
-                continue;
-            }
-
-            requiresReactionComponent = true;
-
-            const normalizedEventName = "on" + capitalizeFirstLetter(item.on);
-
-            if (!Array.isArray(reactionFunctionProps[normalizedEventName])) {
-                // Initialize the key.
-                reactionFunctionProps[normalizedEventName] = [];
-            }
-
-            // Append the reaction function definition that will be read
-            // later by the ReactOnEvent action component.
-            reactionFunctionProps[normalizedEventName].push(item);
-
-            // Do not add the ReactOnEvent component yet in the result array.
-            // It will be added at the end of the actions chain.
-            continue;
-        }
-
-        if (!isValid(item, templateContexts)) {
-            continue;
-        }
-
-        result.push({ActionComponent: Component, actionProps: item, actionIndex: index});
-    }
-
-    if (requiresReactionComponent) {
-        // Add the final component for reaction.
-        // It's added at the end because it will collect all definitions
-        // and apply the reaction function properties on the real rendered element.
-        // TODO: evaluate if the _reactOnEvent actionIndex may create issues.
-        result.push({ActionComponent: ReactOnEvent, actionProps: reactionFunctionProps, actionIndex: "_reactOnEvent"});
-    }
-
-    return result;
-};
-
-/**
- * Maybe converts the given value to a date representation.
- *
- * Needed for date comparisons.
- *
- * @param {boolean} shouldCompareAsDates Tells if the value should be converted.
- * @param {any} a The value to maybe convert.
- *
- * @returns {Date|*} The converted or same value.
- */
-const maybeDate = (shouldCompareAsDates, a) => {
-    return shouldCompareAsDates ? new Date(a) : a;
-};
-
-/**
- * Component that executes actions before rendering its children.
- *
- * Actions include a system to hide.
- *
- * @param props The props that served to build an action dependant component.
- * @returns {*}
- * @constructor
- */
-const ActionDependant = (props) => {
-    const globalDataContext = useContext(GlobalDataContext);
-    const templateContext = useContext(TemplateContext);
-
-    if (!props) {
-        // There is nothing to render or evaluate, so don't even bother checking the actions.
-        return null;
-    }
-
-    const result = getActionsToExecute(props?.actions ?? [], {globalDataContext, templateContext});
-
-    // Encapsulate into actions.
-    return result.reverse().reduce((acc, {ActionComponent, actionProps, actionIndex}) => {
-        // actionProps contains only the info that is related to the action.
-        return <ActionComponent
-            componentProps={props}
-            actionProps={actionProps}
-            actionIndex={actionIndex}>
-            {acc}
-        </ActionComponent>;
-    }, props?.children ?? null);
-};
-
-export default ActionDependant;

package/lib/engine/ComponentCollector.js

@@ -1,28 +0,0 @@
-/**
- * Merges component collections (aka plugins).
- * @param {[{}]} collections Array of plugin collections.
- * @return {{hook: {}, reaction: {}, action: {}, utility: {}, element: {}}}
- */
-export function mergeComponentCollections(collections) {
-    const mergedCollections = {
-        "action": {},
-        "element": {},
-        "hook": {},
-        "reaction": {},
-        "utility": {},
-    };
-
-    collections.forEach((collection) => {
-        for (const [k, v] of Object.entries(collection)) {
-            if (!mergedCollections.hasOwnProperty(k)) {
-                mergedCollections[k] = [];
-            }
-
-            for (const [componentName, Component] of Object.entries(v)) {
-                mergedCollections[componentName] = Component;
-            }
-        }
-    });
-
-    return mergedCollections;
-}

package/lib/engine/EventDispatcherProvider.jsx

@@ -1,80 +0,0 @@
-import {memo} from "react";
-import EventDispatcherContext from "./EventDispatcherContext";
-
-/**
- * Contains the registered listeners. It's shared between all the components.
- *
- * @type {{}}
- */
-const events = {};
-
-/**
- * The main dispatcher which will really be called by the browser's event system.
- *
- * @param {Event} event The event sent by the browser, which will be transferred to the registered listeners.
- */
-const mainDispatcher = (event) => {
-    if (!events.hasOwnProperty(event.type)) {
-        // Ignore this event.
-        return;
-    }
-
-    for (const registeredListener of events[event.type]) {
-        // Inject the event details into the registered listener.
-        registeredListener(event);
-    }
-};
-
-/**
- * Adds the listener to registered listeners.
- *
- * @param {string} type The event type.
- * @param {Function} listener The event listener.
- */
-export const addEventListener = (type, listener) => {
-    if (events.hasOwnProperty(type)) {
-        events[type].push(listener);
-    } else {
-        // This is a new event type. Add the event listener.
-        window.addEventListener(type, mainDispatcher);
-
-        events[type] = [listener];
-    }
-};
-
-/**
- * Removes the specified listener.
- *
- * @param {string} type Event type.
- * @param {Function} listener Event listener.
- */
-export const removeEventListener = (type, listener) => {
-    if (!events.hasOwnProperty(type)) {
-        return;
-    }
-
-    const index = events[type].indexOf(listener);
-
-    if (index > -1) {
-        // Remove once the item.
-        events[type].splice(index, 1);
-    }
-};
-
-/**
- * Use this provider in combination with EventDispatcherContext.
- *
- * @param props
- *
- * @returns {JSX.Element}
- *
- * @constructor
- */
-const EventDispatcherProvider = (props) => {
-    return <EventDispatcherContext.Provider value={{addEventListener, removeEventListener}}>
-        {props.children}
-    </EventDispatcherContext.Provider>;
-}
-
-// TODO: evaluate if memo is useful here.
-export default memo(EventDispatcherProvider);

package/lib/engine/GlobalDataContextProvider.jsx

@@ -1,33 +0,0 @@
-import GlobalDataContext from "./GlobalDataContext";
-
-/**
- * Standard implementation of the provider for GlobalDataContext.
- *
- * @param props Component props. Must have the "value" key.
- *
- * @returns {JSX.Element}
- *
- * @constructor
- */
-const GlobalDataContextProvider = (props) => {
-    // Shallow copy. This will help to keep the original data representation.
-    const valueCopy = {...props.value};
-
-    if (valueCopy.getRootContext === undefined) {
-        // The root context is unset.
-        // Self reference this root object with this closure.
-        // It's useful so that new global data contexts such as those created
-        // by the DataFilter component can access the root global data context value
-        // instead of the current GlobalDataContext value from useContext().
-        // The submitData reaction function uses such root value.
-        valueCopy.getRootContext = () => {
-            return props.value;
-        };
-    }
-
-    return <GlobalDataContext.Provider value={valueCopy}>
-        {props.children}
-    </GlobalDataContext.Provider>;
-}
-
-export default GlobalDataContextProvider;

package/lib/engine/PaginationProvider.jsx

@@ -1,61 +0,0 @@
-import {memo, useReducer, useRef, useState} from "react";
-import PaginationContext from "./PaginationContext";
-
-/**
- * Use this provider in combination with EventDispatcherContext.
- *
- * @param props
- *
- * @returns {JSX.Element}
- *
- * @constructor
- * @deprecated ne fonctionne pas, envisager un système de preemptiveActions pour filtrer les items en amont
- */
-const PaginationProvider = (props) => {
-    const {
-        after,
-        before,
-        contentToPaginate,
-        pagination,
-    } = props;
-    // TODO: essayer d'obtenir le nombre réel à afficher.
-
-    // TODO: essayer d'obtenir seulement les objets à afficher. (Hide lance dispatch(remove) par ex
-    const completeItemCount = contentToPaginate.length;
-
-
-    // Slice for the pagination if in effect.
-    const contentSlice = props?.paginated
-        ? contentToPaginate.slice(pagination.firstShownItemIndex, pagination.maxShownItemIndexExcluded)
-        : contentToPaginate;
-
-
-
-    // Dev note: on PhpStorm, disregard the Function signatures inspection errors of reducers.
-    // See: https://youtrack.jetbrains.com/issue/WEB-53963.
-    // noinspection JSCheckFunctionSignatures
-    const [itemCountAdjustment, dispatchItemCountAdjustment] = useReducer((prevState, dispatched) => {
-        switch (dispatched.type) {
-            case "increment":
-                return prevState + 1;
-
-            case "decrement":
-                return prevState - 1;
-
-            default:
-                // Unknown type.
-                return prevState;
-        }
-    }, {updateId: 0, realCurrentData: {}});
-
-
-
-    return <PaginationContext.Provider value={{dispatchItemCountAdjustment, pagination}}>
-        {before}
-        {contentSlice}
-        {after}
-    </PaginationContext.Provider>;
-}
-
-// TODO: evaluate if memo is useful here.
-export default PaginationProvider;