@openforis/arena-core 2.3.41 → 2.4.0

package/dist/esm/record/_records/recordGetters.js

@@ -1,3 +1,14 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { TraverseMethod } from '../../common';
 import { SystemError } from '../../error';
 import { Nodes } from '../../node';
@@ -9,52 +20,89 @@ import { RECORD_STEP_DEFAULT } from '../record';
 import { RecordStepAnalysisCode } from '../recordStep';
 import { RecordNodesIndexReader } from './recordNodesIndexReader';
 import { NodeDefSelfReferences } from './nodeDefSelfReferences';
+const isRecordParams = (params) => 'record' in params;
+const recordGetter = (getter) => ((params) => isRecordParams(params)
+    ? getter(params)
+    : (record) => getter(Object.assign(Object.assign({}, params), { record })));
+const positionalRecordGetter = (params) => {
+    const { getter, isPositional, toParams } = params;
+    return ((...args) => {
+        const getterParams = isPositional(args[0]) ? toParams(...args) : args[0];
+        return (record) => getter(Object.assign(Object.assign({}, getterParams), { record }));
+    });
+};
+const isRecordNode = (arg) => typeof arg === 'object' && arg !== null && 'uuid' in arg && 'nodeDefUuid' in arg;
+const isString = (arg) => typeof arg === 'string';
 export const getCycle = (record) => { var _a; return (_a = record.cycle) !== null && _a !== void 0 ? _a : defaultCycle; };
 export const getNodes = (record) => { var _a; return (_a = record.nodes) !== null && _a !== void 0 ? _a : {}; };
 export const getNodesArray = (record) => Object.values(getNodes(record));
-export const getNodeByUuid = (uuid) => (record) => { var _a; return (_a = record.nodes) === null || _a === void 0 ? void 0 : _a[uuid]; };
-export const getNodesByUuids = (uuids) => (record) => uuids.map((uuid) => getNodeByUuid(uuid)(record));
+export const getNodeByUuid = positionalRecordGetter({
+    getter: ({ record, uuid }) => { var _a; return (_a = record.nodes) === null || _a === void 0 ? void 0 : _a[uuid]; },
+    isPositional: isString,
+    toParams: (uuid) => ({ uuid }),
+});
+export const getNodesByUuids = positionalRecordGetter({
+    getter: ({ record, uuids }) => uuids.map((uuid) => { var _a; return (_a = record.nodes) === null || _a === void 0 ? void 0 : _a[uuid]; }),
+    isPositional: Array.isArray,
+    toParams: (uuids) => ({ uuids }),
+});
 export const getRoot = (record) => {
     const rootUuid = record._nodesIndex ? RecordNodesIndexReader.getNodeRootUuid(record._nodesIndex) : null;
     if (rootUuid) {
-        return getNodeByUuid(rootUuid)(record);
+        return getNodeByUuid({ uuid: rootUuid })(record);
     }
     return getNodesArray(record).find((node) => !node.parentUuid);
 };
-export const getChildren = (parentNode, childDefUuid) => (record) => {
-    if (record._nodesIndex) {
-        const childrenUuids = childDefUuid
-            ? RecordNodesIndexReader.getNodeUuidsByParentAndChildDef({
-                parentNodeUuid: parentNode.uuid,
-                childDefUuid,
-            })(record._nodesIndex)
-            : RecordNodesIndexReader.getNodeUuidsByParent(parentNode.uuid)(record._nodesIndex);
-        return getNodesByUuids(childrenUuids)(record);
-    }
-    return getNodesArray(record).filter((node) => node.parentUuid === parentNode.uuid && (!childDefUuid || node.nodeDefUuid == childDefUuid));
-};
-export const getChild = (parentNode, childDefUuid) => (record) => {
-    const children = getChildren(parentNode, childDefUuid)(record);
-    const errorParams = { childDefUuid, parentNodeUuid: parentNode.uuid, recordUuid: record.uuid };
-    if (children.length === 1) {
-        return children[0];
-    }
-    if (children.length > 1) {
-        throw new SystemError('systemError.record.multipleNodesFound', errorParams);
-    }
-    throw new SystemError('systemError.record.childNotFound', errorParams);
-};
-export const getParent = (node) => (record) => node.parentUuid ? getNodeByUuid(node.parentUuid)(record) : undefined;
-export const getNodesByDefUuid = (nodeDefUuid) => (record) => {
-    if (record._nodesIndex) {
-        const nodeUuids = RecordNodesIndexReader.getNodeUuidsByDef(nodeDefUuid)(record._nodesIndex);
-        return getNodesByUuids(nodeUuids)(record);
-    }
-    return getNodesArray(record).filter((node) => node.nodeDefUuid === nodeDefUuid);
-};
-const isNodeFlagTrue = (isChildFlagTrue) => (params) => {
+export const getChildren = positionalRecordGetter({
+    getter: ({ record, parentNode, childDefUuid, }) => {
+        if (record._nodesIndex) {
+            const childrenUuids = childDefUuid
+                ? RecordNodesIndexReader.getNodeUuidsByParentAndChildDef({
+                    parentNodeUuid: parentNode.uuid,
+                    childDefUuid,
+                })(record._nodesIndex)
+                : RecordNodesIndexReader.getNodeUuidsByParent(parentNode.uuid)(record._nodesIndex);
+            return getNodesByUuids({ uuids: childrenUuids })(record);
+        }
+        return getNodesArray(record).filter((node) => node.parentUuid === parentNode.uuid && (!childDefUuid || node.nodeDefUuid == childDefUuid));
+    },
+    isPositional: isRecordNode,
+    toParams: (parentNode, childDefUuid) => ({ parentNode, childDefUuid }),
+});
+export const getChild = positionalRecordGetter({
+    getter: ({ record, parentNode, childDefUuid, }) => {
+        const children = getChildren({ parentNode, childDefUuid })(record);
+        const errorParams = { childDefUuid, parentNodeUuid: parentNode.uuid, recordUuid: record.uuid };
+        if (children.length === 1) {
+            return children[0];
+        }
+        if (children.length > 1) {
+            throw new SystemError('systemError.record.multipleNodesFound', errorParams);
+        }
+        throw new SystemError('systemError.record.childNotFound', errorParams);
+    },
+    isPositional: isRecordNode,
+    toParams: (parentNode, childDefUuid) => ({ parentNode, childDefUuid }),
+});
+export const getParent = positionalRecordGetter({
+    getter: ({ record, node }) => node.parentUuid ? getNodeByUuid({ uuid: node.parentUuid })(record) : undefined,
+    isPositional: isRecordNode,
+    toParams: (node) => ({ node }),
+});
+export const getNodesByDefUuid = positionalRecordGetter({
+    getter: ({ record, nodeDefUuid }) => {
+        if (record._nodesIndex) {
+            const nodeUuids = RecordNodesIndexReader.getNodeUuidsByDef(nodeDefUuid)(record._nodesIndex);
+            return getNodesByUuids({ uuids: nodeUuids })(record);
+        }
+        return getNodesArray(record).filter((node) => node.nodeDefUuid === nodeDefUuid);
+    },
+    isPositional: isString,
+    toParams: (nodeDefUuid) => ({ nodeDefUuid }),
+});
+const isNodeFlagTrue = (isChildFlagTrue) => recordGetter((params) => {
     const { record, node } = params;
-    const ancestorsAndSelf = getAncestorsAndSelf({ record, node });
+    const ancestorsAndSelf = getAncestorsAndSelf({ node })(record);
     for (let i = 0; i < ancestorsAndSelf.length - 1; i++) {
         const child = ancestorsAndSelf[i];
         const parent = ancestorsAndSelf[i + 1];
@@ -62,25 +110,29 @@ const isNodeFlagTrue = (isChildFlagTrue) => (params) => {
             return false;
     }
     return true;
-};
+});
 export const isNodeApplicable = isNodeFlagTrue((parent, nodeDefUuid) => Nodes.isChildApplicable(parent, nodeDefUuid));
 export const isNodeEditable = isNodeFlagTrue((parent, nodeDefUuid) => Nodes.isChildEditable(parent, nodeDefUuid));
 export const isNodeVisible = isNodeFlagTrue((parent, nodeDefUuid) => Nodes.isChildVisible(parent, nodeDefUuid));
-export const getDependentCodeAttributes = (node) => (record) => {
-    if (record._nodesIndex) {
-        const nodeUuids = RecordNodesIndexReader.getNodeCodeDependentUuids(node.uuid)(record._nodesIndex);
-        return getNodesByUuids(nodeUuids)(record);
-    }
-    throw new SystemError('record.nodesIndexNotInitialized');
-};
+export const getDependentCodeAttributes = positionalRecordGetter({
+    getter: ({ record, node }) => {
+        if (record._nodesIndex) {
+            const nodeUuids = RecordNodesIndexReader.getNodeCodeDependentUuids(node.uuid)(record._nodesIndex);
+            return getNodesByUuids({ uuids: nodeUuids })(record);
+        }
+        throw new SystemError('record.nodesIndexNotInitialized');
+    },
+    isPositional: isRecordNode,
+    toParams: (node) => ({ node }),
+});
 export const getParentCodeAttribute = (params) => (record) => {
     const { parentNode, nodeDef } = params;
     const parentCodeDefUuid = NodeDefs.getParentCodeDefUuid(nodeDef);
     if (!parentCodeDefUuid)
         return undefined;
-    const ancestors = getAncestorsAndSelf({ record, node: parentNode });
+    const ancestors = getAncestorsAndSelf({ node: parentNode })(record);
     for (const ancestor of ancestors) {
-        const children = getChildren(ancestor, parentCodeDefUuid)(record);
+        const children = getChildren({ parentNode: ancestor, childDefUuid: parentCodeDefUuid })(record);
         if (children.length === 1) {
             return children[0];
         }
@@ -88,47 +140,72 @@ export const getParentCodeAttribute = (params) => (record) => {
     return undefined;
 };
 // ancestors
-export const visitAncestorsAndSelf = (node, visitor, stopIfFn) => (record) => {
-    let currentNode = node;
-    while (currentNode) {
-        visitor(currentNode);
-        if (stopIfFn === null || stopIfFn === void 0 ? void 0 : stopIfFn())
-            break;
-        currentNode = getParent(currentNode)(record);
-    }
-};
-export const findAncestor = (node, predicate) => (record) => {
-    let result = undefined;
-    visitAncestorsAndSelf(node, (visitedNode) => {
-        if (predicate(visitedNode)) {
-            result = visitedNode;
+/**
+ * Visits the specified node and its ancestors, from the node up to the root: the visit stops when the visitor returns true.
+ */
+export const visitAncestorsAndSelf = positionalRecordGetter({
+    getter: ({ record, node, visitor, }) => {
+        let currentNode = node;
+        while (currentNode) {
+            if (visitor(currentNode))
+                return;
+            currentNode = getParent({ node: currentNode })(record);
         }
-    }, () => !!result)(record);
+    },
+    isPositional: isRecordNode,
+    // deprecated form: the visit stops when stopIfFn returns true
+    toParams: (node, visitor, stopIfFn) => ({
+        node,
+        visitor: (visitedNode) => {
+            visitor(visitedNode);
+            return !!(stopIfFn === null || stopIfFn === void 0 ? void 0 : stopIfFn());
+        },
+    }),
+});
+/**
+ * Returns the first node satisfying the predicate among the specified node and its ancestors (from the node up to the root).
+ */
+export const findAncestor = (params) => (record) => {
+    const { node, predicate } = params;
+    let result = undefined;
+    visitAncestorsAndSelf({
+        node,
+        visitor: (visitedNode) => {
+            if (predicate(visitedNode)) {
+                result = visitedNode;
+                return true;
+            }
+            return false;
+        },
+    })(record);
     return result;
 };
-export const getAncestor = (params) => {
+export const getAncestor = recordGetter((params) => {
     const { record, node, ancestorDefUuid } = params;
     if (node.nodeDefUuid === ancestorDefUuid)
         return node;
-    let ancestor = getParent(node)(record);
+    let ancestor = getParent({ node })(record);
     while (ancestor && ancestor.nodeDefUuid !== ancestorDefUuid) {
-        ancestor = getParent(ancestor)(record);
+        ancestor = getParent({ node: ancestor })(record);
     }
     return ancestor;
-};
+});
 /**
  * Returns the list of ancestors from the given node to the root entity
  */
-export const getAncestorsAndSelf = (params) => {
+export const getAncestorsAndSelf = recordGetter((params) => {
     const { record, node } = params;
     const ancestors = [];
-    visitAncestorsAndSelf(node, (currentNode) => {
-        ancestors.push(currentNode);
+    visitAncestorsAndSelf({
+        node,
+        visitor: (currentNode) => {
+            ancestors.push(currentNode);
+        },
     })(record);
     return ancestors;
-};
+});
 // descendants
-export const getDescendantsOrSelf = (params) => {
+export const getDescendantsOrSelf = recordGetter((params) => {
     const { record, node, nodeDefDescendant } = params;
     if (nodeDefDescendant.uuid === node.nodeDefUuid)
         return [node];
@@ -140,22 +217,22 @@ export const getDescendantsOrSelf = (params) => {
     let currentDescendants = [];
     for (const currentDescendantDefUuid of descendantNodeDefUuids) {
         for (const currentAncestor of currentAncestors) {
-            currentDescendants.push(...getChildren(currentAncestor, currentDescendantDefUuid)(record));
+            currentDescendants.push(...getChildren({ parentNode: currentAncestor, childDefUuid: currentDescendantDefUuid })(record));
         }
         currentAncestors = currentDescendants;
         currentDescendants = [];
     }
     return currentAncestors; // currentAncestors is equal to the currentDescendants of the last level
-};
-export const getDescendant = (params) => {
+});
+export const getDescendant = recordGetter((params) => {
     const { record, node, nodeDefDescendant } = params;
-    return getDescendantsOrSelf({ record, node, nodeDefDescendant })[0];
-};
+    return getDescendantsOrSelf({ node, nodeDefDescendant })(record)[0];
+});
 export const isDescendantOf = (params) => {
     const { node, ancestor } = params;
     return Nodes.getHierarchy(node).includes(ancestor.uuid);
 };
-export const visitDescendantsAndSelf = (params) => {
+export const visitDescendantsAndSelf = recordGetter((params) => {
     const { record, node, visitor, traverseMethod = TraverseMethod.bfs } = params;
     if (traverseMethod === TraverseMethod.bfs) {
         const queue = new Queue();
@@ -179,7 +256,7 @@ export const visitDescendantsAndSelf = (params) => {
                 // stop if visitor returns true
                 return;
             }
-            const children = getChildren(visitedNode)(record);
+            const children = getChildren({ parentNode: visitedNode })(record);
             // add children to stack in reverse order
             for (let index = children.length - 1; index >= 0; index--) {
                 const child = children[index];
@@ -187,11 +264,11 @@ export const visitDescendantsAndSelf = (params) => {
             }
         }
     }
-};
-export const findDescendantOrSelf = (node, predicate) => (record) => {
+});
+export const findDescendantOrSelf = (params) => (record) => {
+    const { node, predicate } = params;
     let found = undefined;
     visitDescendantsAndSelf({
-        record,
         node,
         visitor: (currentNode) => {
             if (predicate(currentNode)) {
@@ -200,10 +277,10 @@ export const findDescendantOrSelf = (node, predicate) => (record) => {
             }
             return false;
         },
-    });
+    })(record);
     return found;
 };
-const getClosestAncestorNode = (params) => {
+const getClosestAncestorNode = recordGetter((params) => {
     const { record, node, nodeDef, dependentDef, dependencyType } = params;
     // 1a if dependent def is the same as node def, potentially all nodes with
     // nodeDefUuid === dependentDef.uuid in record could be dependent of nodeDef;
@@ -211,7 +288,7 @@ const getClosestAncestorNode = (params) => {
     // unless the node def references itself only among the children of its parent entity (e.g. validation "dbh > 0")
     if (nodeDef.uuid === dependentDef.uuid) {
         return NodeDefSelfReferences.isSelfReferenceLocal({ nodeDef, dependencyType })
-            ? getParent(node)(record)
+            ? getParent({ node })(record)
             : getRoot(record);
     }
     // 1 find common ancestor def
@@ -219,69 +296,71 @@ const getClosestAncestorNode = (params) => {
     if (!commonAncestorDefUuid)
         return undefined;
     // 2 get ancestor node with common parent def
-    return getAncestor({ record, node, ancestorDefUuid: commonAncestorDefUuid });
-};
-export const getEntityKeyNodesByDefUuid = (params) => {
+    return getAncestor({ node, ancestorDefUuid: commonAncestorDefUuid })(record);
+});
+export const getEntityKeyNodesByDefUuid = recordGetter((params) => {
     const { survey, cycle, record, entity, keyDefs } = params;
     const nodeDef = Surveys.getNodeDefByUuid({ survey, uuid: entity.nodeDefUuid });
     const nodeDefKeys = keyDefs !== null && keyDefs !== void 0 ? keyDefs : Surveys.getNodeDefKeys({ survey, cycle, nodeDef });
     return nodeDefKeys.reduce((acc, nodeDefKey) => {
-        const nodeKey = getDescendant({ record, node: entity, nodeDefDescendant: nodeDefKey });
+        const nodeKey = getDescendant({ node: entity, nodeDefDescendant: nodeDefKey })(record);
         acc[nodeDefKey.uuid] = nodeKey;
         return acc;
     }, {});
-};
-export const getEntityKeyNodes = (params) => Object.values(getEntityKeyNodesByDefUuid(params));
-export const getEntityKeyValuesByDefUuid = (params) => {
-    const keyNodesByDefUuid = getEntityKeyNodesByDefUuid(params);
+});
+export const getEntityKeyNodes = recordGetter((_a) => {
+    var { record } = _a, otherParams = __rest(_a, ["record"]);
+    return Object.values(getEntityKeyNodesByDefUuid(otherParams)(record));
+});
+export const getEntityKeyValuesByDefUuid = recordGetter((params) => {
+    const { record } = params, otherParams = __rest(params, ["record"]);
+    const keyNodesByDefUuid = getEntityKeyNodesByDefUuid(otherParams)(record);
     return Object.entries(keyNodesByDefUuid).reduce((acc, [uuid, keyNode]) => {
         acc[uuid] = keyNode === null || keyNode === void 0 ? void 0 : keyNode.value;
         return acc;
     }, {});
-};
-export const getEntityKeyValues = (params) => Object.values(getEntityKeyValuesByDefUuid(params));
-export const getEntitySiblings = (params) => {
+});
+export const getEntityKeyValues = recordGetter((_a) => {
+    var { record } = _a, otherParams = __rest(_a, ["record"]);
+    return Object.values(getEntityKeyValuesByDefUuid(otherParams)(record));
+});
+export const getEntitySiblings = recordGetter((params) => {
     const { record, entity, includeSelf = false } = params;
-    const parentEntity = getParent(entity)(record);
+    const parentEntity = getParent({ node: entity })(record);
     if (!parentEntity)
         return [];
-    const siblingEntities = getChildren(parentEntity, entity.nodeDefUuid)(record);
+    const siblingEntities = getChildren({ parentNode: parentEntity, childDefUuid: entity.nodeDefUuid })(record);
     return includeSelf ? siblingEntities : siblingEntities.filter((sibling) => !Nodes.areEqual(sibling, entity));
-};
-export const getAttributeSiblings = (params) => {
+});
+export const getAttributeSiblings = recordGetter((params) => {
     const { record, node, nodeDef } = params;
-    const parentEntity = getParent(node)(record);
+    const parentEntity = getParent({ node })(record);
     if (!parentEntity)
         return [];
-    const siblingParentEntities = getEntitySiblings({ record, entity: parentEntity });
+    const siblingParentEntities = getEntitySiblings({ entity: parentEntity })(record);
     return siblingParentEntities.reduce((siblingsAcc, siblingEntity) => {
-        siblingsAcc.push(...getChildren(siblingEntity, nodeDef.uuid)(record));
+        siblingsAcc.push(...getChildren({ parentNode: siblingEntity, childDefUuid: nodeDef.uuid })(record));
         return siblingsAcc;
     }, []);
-};
-export const getNodeIndex = (params) => {
+});
+export const getNodeIndex = recordGetter((params) => {
     const { record, node } = params;
-    const parentEntity = getParent(node)(record);
+    const parentEntity = getParent({ node })(record);
     if (!parentEntity)
         return 0; // root entity
-    const siblings = getChildren(parentEntity, node.nodeDefUuid)(record);
+    const siblings = getChildren({ parentNode: parentEntity, childDefUuid: node.nodeDefUuid })(record);
     return siblings.indexOf(node);
-};
-export const findEntityByKeyValues = (params) => {
+});
+export const findEntityByKeyValues = recordGetter((params) => {
     const { survey, cycle, record, parentEntity, entityDefUuid, keyValuesByDefUuid } = params;
     const entityDef = Surveys.getNodeDefByUuid({ survey, uuid: entityDefUuid });
-    const siblingEntities = getChildren(parentEntity, entityDefUuid)(record);
+    const siblingEntities = getChildren({ parentNode: parentEntity, childDefUuid: entityDefUuid })(record);
     if (NodeDefs.isSingle(entityDef)) {
         return siblingEntities[0];
     }
     const keyDefs = Surveys.getNodeDefKeys({ survey, cycle, nodeDef: entityDef });
     return siblingEntities.find((siblingEntity) => {
-        const siblingEntityKeyValuesByDefUuid = getEntityKeyValuesByDefUuid({
-            survey,
-            record,
-            entity: siblingEntity,
-            keyDefs,
-        });
+        const siblingEntityKeyValuesByDefUuid = getEntityKeyValuesByDefUuid({ survey, entity: siblingEntity, keyDefs })(record);
         return keyDefs.every((keyDef) => {
             const keyValue = siblingEntityKeyValuesByDefUuid[keyDef.uuid];
             const keyValueSearch = keyValuesByDefUuid[keyDef.uuid];
@@ -293,26 +372,19 @@ export const findEntityByKeyValues = (params) => {
             });
         });
     });
-};
-export const findEntityWithSameKeysInAnotherRecord = (params) => {
+});
+export const findEntityWithSameKeysInAnotherRecord = recordGetter((params) => {
     const { survey, cycle, entityUuid, record, recordOther } = params;
-    const entity = getNodeByUuid(entityUuid)(record);
+    const entity = getNodeByUuid({ uuid: entityUuid })(record);
     if (!entity)
         return undefined;
     let otherRecordCurrentParentEntity = getRoot(recordOther);
     if (!otherRecordCurrentParentEntity)
         return undefined;
-    const entityAncestorsAndSelf = getAncestorsAndSelf({
-        record,
-        node: entity,
-    });
+    const entityAncestorsAndSelf = getAncestorsAndSelf({ node: entity })(record);
     const ancestorDefUuidsAndKeys = entityAncestorsAndSelf.map((ancestor) => ({
         entityDefUuid: ancestor.nodeDefUuid,
-        keyValuesByDefUuid: getEntityKeyValuesByDefUuid({
-            survey,
-            record,
-            entity: ancestor,
-        }),
+        keyValuesByDefUuid: getEntityKeyValuesByDefUuid({ survey, entity: ancestor })(record),
     }));
     const ancestorDefUuidsAndKeysToVisit = [...ancestorDefUuidsAndKeys].reverse();
     for (let index = 1; otherRecordCurrentParentEntity && index < ancestorDefUuidsAndKeysToVisit.length; index++) {
@@ -320,15 +392,14 @@ export const findEntityWithSameKeysInAnotherRecord = (params) => {
         otherRecordCurrentParentEntity = findEntityByKeyValues({
             survey,
             cycle,
-            record: recordOther,
             parentEntity: otherRecordCurrentParentEntity,
             entityDefUuid,
             keyValuesByDefUuid,
-        });
+        })(recordOther);
     }
     return otherRecordCurrentParentEntity;
-};
-export const getDependentNodePointers = (params) => {
+});
+export const getDependentNodePointers = recordGetter((params) => {
     const { survey, record, node, dependencyType, includeSelf = false, filterFn = null } = params;
     const nodeDefUuid = node.nodeDefUuid;
     const nodeDef = Surveys.getNodeDefByUuid({ survey, uuid: nodeDefUuid });
@@ -341,7 +412,7 @@ export const getDependentNodePointers = (params) => {
     };
     for (const dependentDef of dependentDefs) {
         // 1 find common ancestor node
-        const commonAncestorNode = getClosestAncestorNode({ record, node, nodeDef, dependentDef, dependencyType });
+        const commonAncestorNode = getClosestAncestorNode({ node, nodeDef, dependentDef, dependencyType })(record);
         if (!commonAncestorNode)
             continue;
         const nodeDefDependentParent = Surveys.getNodeDefParent({ survey, nodeDef: dependentDef });
@@ -349,10 +420,9 @@ export const getDependentNodePointers = (params) => {
             throw new SystemError('record.nodes.dependents.dependencyOnRootFound');
         // 2 find descendant nodes of common parent node with nodeDefUuid = dependentDef uuid
         const dependentContextNodes = getDescendantsOrSelf({
-            record,
             node: commonAncestorNode,
             nodeDefDescendant: nodeDefDependentParent,
-        });
+        })(record);
         for (const dependentContextNode of dependentContextNodes) {
             addToNodePointers({
                 nodeCtx: dependentContextNode,
@@ -361,7 +431,7 @@ export const getDependentNodePointers = (params) => {
         }
     }
     if (includeSelf) {
-        const parentNode = getParent(node)(record);
+        const parentNode = getParent({ node })(record);
         if (parentNode) {
             addToNodePointers({
                 nodeCtx: parentNode,
@@ -370,8 +440,8 @@ export const getDependentNodePointers = (params) => {
         }
     }
     return nodePointers;
-};
-export const getAncestorCodePath = (params) => {
+});
+export const getAncestorCodePath = recordGetter((params) => {
     const { record, parentNode, nodeDef, survey } = params;
     const getCodeAttributeItemCode = (codeAttribute) => {
         var _a;
@@ -393,19 +463,27 @@ export const getAncestorCodePath = (params) => {
         currentParentCodeAttribute = getParentCodeAttribute({ parentNode, nodeDef: ancestorCodeDef })(record);
     }
     return codePaths;
-};
-export const getCategoryItemUuid = (params) => {
+});
+export const getCategoryItemUuid = recordGetter((params) => {
     const { survey, nodeDef, record, parentNode, code } = params;
     const categoryUuid = nodeDef.props.categoryUuid;
-    const codePaths = [...getAncestorCodePath({ survey, record, parentNode, nodeDef }), code];
+    const codePaths = [...getAncestorCodePath({ survey, parentNode, nodeDef })(record), code];
     const item = Surveys.getCategoryItemByCodePaths({ survey, categoryUuid, codePaths });
     return item === null || item === void 0 ? void 0 : item.uuid;
-};
-export const isNodeFilledByUser = (node) => (record) => !!findDescendantOrSelf(node, (visitedNode) => Nodes.hasUserInputValue(visitedNode))(record);
-export const isNodeEmpty = (node) => (record) => !isNodeFilledByUser(node)(record);
+});
+export const isNodeFilledByUser = positionalRecordGetter({
+    getter: ({ record, node }) => !!findDescendantOrSelf({ node, predicate: (visitedNode) => Nodes.hasUserInputValue(visitedNode) })(record),
+    isPositional: isRecordNode,
+    toParams: (node) => ({ node }),
+});
+export const isNodeEmpty = positionalRecordGetter({
+    getter: ({ record, node }) => !isNodeFilledByUser({ node })(record),
+    isPositional: isRecordNode,
+    toParams: (node) => ({ node }),
+});
 export const isEmpty = (record) => {
     const rootNode = getRoot(record);
-    return rootNode ? isNodeEmpty(rootNode)(record) : true;
+    return rootNode ? isNodeEmpty({ node: rootNode })(record) : true;
 };
 export const getStep = (record) => { var _a; return (_a = record.step) !== null && _a !== void 0 ? _a : RECORD_STEP_DEFAULT; };
 export const isInAnalysisStep = (record) => getStep(record) === RecordStepAnalysisCode;