@gogocat/data-bind 1.12.0 → 2.0.0

package/src/{commentWrapper.js → commentWrapper.ts}

@@ -1,15 +1,16 @@
-/* eslint-disable no-invalid-this */
+
 import * as config from './config';
 import * as util from './util';
+import type {BindingCache} from './types';
 
-const createClonedElementCache = (bindingData) => {
+const createClonedElementCache = (bindingData: BindingCache): BindingCache => {
     const clonedElement = bindingData.el.cloneNode(true);
     bindingData.fragment = document.createDocumentFragment();
     bindingData.fragment.appendChild(clonedElement);
     return bindingData;
 };
 
-const setCommentPrefix = (bindingData) => {
+const setCommentPrefix = (bindingData: BindingCache): BindingCache => {
     if (!bindingData || !bindingData.type) {
         return bindingData;
     }
@@ -17,18 +18,18 @@ const setCommentPrefix = (bindingData) => {
     const dataKeyMarker = bindingData.dataKey ? bindingData.dataKey.replace(util.REGEX.WHITE_SPACES, '_') : '';
 
     switch (bindingData.type) {
-    case config.bindingAttrs.forOf:
-        commentPrefix = config.commentPrefix.forOf;
-        break;
-    case config.bindingAttrs.if:
-        commentPrefix = config.commentPrefix.if;
-        break;
-    case config.bindingAttrs.case:
-        commentPrefix = config.commentPrefix.case;
-        break;
-    case config.bindingAttrs.default:
-        commentPrefix = config.commentPrefix.default;
-        break;
+        case config.bindingAttrs.forOf:
+            commentPrefix = config.commentPrefix.forOf;
+            break;
+        case config.bindingAttrs.if:
+            commentPrefix = config.commentPrefix.if;
+            break;
+        case config.bindingAttrs.case:
+            commentPrefix = config.commentPrefix.case;
+            break;
+        case config.bindingAttrs.default:
+            commentPrefix = config.commentPrefix.default;
+            break;
     }
     bindingData.commentPrefix = commentPrefix + dataKeyMarker;
     return bindingData;
@@ -44,18 +45,18 @@ const setCommentPrefix = (bindingData) => {
  * if not found deleteContents will has no operation
  * @return {undefined}
  */
-const setDocRangeEndAfter = (node, bindingData) => {
+const setDocRangeEndAfter = (node: Node | null, bindingData: BindingCache): void => {
     if (!bindingData.commentPrefix) {
         setCommentPrefix(bindingData);
     }
-    const startTextContent = bindingData.commentPrefix;
+    const startTextContent = bindingData.commentPrefix as string;
     const endTextContent = startTextContent + config.commentSuffix;
     node = node.nextSibling;
 
     // check last wrap comment node
     if (node) {
         if (node.nodeType === 8 && node.textContent === endTextContent) {
-            return bindingData.docRange.setEndBefore(node);
+            return (bindingData.docRange as Range).setEndBefore(node);
         }
         setDocRangeEndAfter(node, bindingData);
     }
@@ -69,12 +70,12 @@ const setDocRangeEndAfter = (node, bindingData) => {
  * @description
  * wrap frament with comment node
  */
-const wrapCommentAround = (bindingData, node) => {
+const wrapCommentAround = (bindingData: BindingCache, node: Node | DocumentFragment): Node | DocumentFragment => {
     let prefix = '';
     if (!bindingData.commentPrefix) {
         setCommentPrefix(bindingData);
     }
-    prefix = bindingData.commentPrefix;
+    prefix = bindingData.commentPrefix as string;
     const commentBegin = document.createComment(prefix);
     const commentEnd = document.createComment(prefix + config.commentSuffix);
     // document fragment - logic for ForOf binding
@@ -100,25 +101,26 @@ const wrapCommentAround = (bindingData, node) => {
  * @return {undefined}
  * @description remove elments by range
  */
-const removeElemnetsByCommentWrap = (bindingData) => {
+const removeElemnetsByCommentWrap = (bindingData: BindingCache): void => {
     if (!bindingData.docRange) {
         bindingData.docRange = document.createRange();
     }
+    const docRange = bindingData.docRange as Range;
     try {
         if (bindingData.previousNonTemplateElement) {
             // update docRange start and end match the wrapped comment node
-            bindingData.docRange.setStartBefore(bindingData.previousNonTemplateElement.nextSibling);
+            docRange.setStartBefore(bindingData.previousNonTemplateElement.nextSibling as Node);
             setDocRangeEndAfter(bindingData.previousNonTemplateElement.nextSibling, bindingData);
         } else {
             // insert before next non template element
-            bindingData.docRange.setStartBefore(bindingData.parentElement.firstChild);
-            setDocRangeEndAfter(bindingData.parentElement.firstChild, bindingData);
+            docRange.setStartBefore((bindingData.parentElement as HTMLElement).firstChild as Node);
+            setDocRangeEndAfter((bindingData.parentElement as HTMLElement).firstChild, bindingData);
         }
-    } catch (err) {
-        console.log('error removeElemnetsByCommentWrap: ', err.message);
+    } catch (err: unknown) {
+        console.log('error removeElemnetsByCommentWrap: ', err instanceof Error ? err.message : String(err));
     }
 
-    return bindingData.docRange.deleteContents();
+    docRange.deleteContents();
 };
 
 /**
@@ -126,15 +128,16 @@ const removeElemnetsByCommentWrap = (bindingData) => {
  * @param {object} bindingData
  * @return {object} null
  */
-const removeDomTemplateElement = (bindingData) => {
+const removeDomTemplateElement = (bindingData: BindingCache): void => {
     // first render - forElement is live DOM element so has parentNode
     if (bindingData.el.parentNode) {
-        return bindingData.el.parentNode.removeChild(bindingData.el);
+        bindingData.el.parentNode.removeChild(bindingData.el);
+        return;
     }
     removeElemnetsByCommentWrap(bindingData);
 };
 
-const insertRenderedElements = (bindingData, fragment) => {
+const insertRenderedElements = (bindingData: BindingCache, fragment: DocumentFragment): void => {
     // insert rendered fragment after the previousNonTemplateElement
     if (bindingData.previousNonTemplateElement) {
         util.insertAfter(bindingData.parentElement, fragment, bindingData.previousNonTemplateElement);

package/src/config.ts

@@ -0,0 +1,107 @@
+export interface BindingAttrs {
+    comp: string;
+    tmp: string;
+    text: string;
+    click: string;
+    dblclick: string;
+    blur: string;
+    focus: string;
+    hover: string;
+    input: string;
+    change: string;
+    submit: string;
+    model: string;
+    show: string;
+    css: string;
+    attr: string;
+    forOf: string;
+    if: string;
+    switch: string;
+    case: string;
+    default: string;
+}
+
+export const bindingAttrs: BindingAttrs = {
+    comp: 'data-bind-comp',
+    tmp: 'data-bind-tmp',
+    text: 'data-bind-text',
+    click: 'data-bind-click',
+    dblclick: 'data-bind-dblclick',
+    blur: 'data-bind-blur',
+    focus: 'data-bind-focus',
+    hover: 'data-bind-hover',
+    input: 'data-bind-input',
+    change: 'data-bind-change',
+    submit: 'data-bind-submit',
+    model: 'data-bind-model',
+    show: 'data-bind-show',
+    css: 'data-bind-css',
+    attr: 'data-bind-attr',
+    forOf: 'data-bind-for',
+    if: 'data-bind-if',
+    switch: 'data-bind-switch',
+    case: 'data-bind-case',
+    default: 'data-bind-default',
+};
+
+export const serverRenderedAttr = 'data-server-rendered';
+export const dataIndexAttr = 'data-index';
+
+export interface CommentPrefix {
+    forOf: string;
+    if: string;
+    case: string;
+    default: string;
+}
+
+export const commentPrefix: CommentPrefix = {
+    forOf: 'data-forOf_',
+    if: 'data-if_',
+    case: 'data-case_',
+    default: 'data-default_',
+};
+
+export const commentSuffix = '_end';
+
+export interface BindingDataReference {
+    rootDataKey: string;
+    currentData: string;
+    currentIndex: string;
+    mouseEnterHandlerName: string;
+    mouseLeaveHandlerName: string;
+}
+
+export const bindingDataReference: BindingDataReference = {
+    rootDataKey: '$root',
+    currentData: '$data',
+    currentIndex: '$index',
+    mouseEnterHandlerName: 'in',
+    mouseLeaveHandlerName: 'out',
+};
+
+export interface BindingUpdateConditions {
+    serverRendered: string;
+    init: string;
+}
+
+export const bindingUpdateConditions: BindingUpdateConditions = {
+    serverRendered: 'SERVER-RENDERED',
+    init: 'INIT',
+};
+
+// maximum string length before running regex
+export const maxDatakeyLength = 250;
+
+export interface Constants {
+    filters: {
+        ONCE: string;
+    };
+    PARENT_REF: string;
+}
+
+export const constants: Constants = {
+    filters: {
+        ONCE: 'once',
+    },
+    PARENT_REF: '_parent',
+};

package/src/{createBindingOption.js → createBindingOption.ts}

@@ -2,6 +2,29 @@ import {
     bindingUpdateConditions,
 } from './config';
 import {extend} from './util';
+
+export interface BindingOption {
+    templateBinding?: boolean;
+    textBinding?: boolean;
+    cssBinding?: boolean;
+    ifBinding?: boolean;
+    showBinding?: boolean;
+    modelBinding?: boolean;
+    attrBinding?: boolean;
+    forOfBinding?: boolean;
+    switchBinding?: boolean;
+    changeBinding?: boolean;
+    clickBinding?: boolean;
+    dblclickBinding?: boolean;
+    blurBinding?: boolean;
+    focusBinding?: boolean;
+    hoverBinding?: boolean;
+    inputBinding?: boolean;
+    submitBinding?: boolean;
+    forceRender?: boolean;
+    [key: string]: unknown;
+}
+
 /**
  * createBindingOption
  * @param {string} condition
@@ -10,8 +33,8 @@ import {extend} from './util';
  * generate binding update option object by condition
  * @return {object} updateOption
  */
-function createBindingOption(condition = '', opt = {}) {
-    const visualBindingOptions = {
+const createBindingOption = (condition: string = '', opt: BindingOption = {}): BindingOption => {
+    const visualBindingOptions: BindingOption = {
         templateBinding: false,
         textBinding: true,
         cssBinding: true,
@@ -22,7 +45,7 @@ function createBindingOption(condition = '', opt = {}) {
         forOfBinding: true,
         switchBinding: true,
     };
-    const eventsBindingOptions = {
+    const eventsBindingOptions: BindingOption = {
         changeBinding: true,
         clickBinding: true,
         dblclickBinding: true,
@@ -34,7 +57,7 @@ function createBindingOption(condition = '', opt = {}) {
     };
     // this is visualBindingOptions but everything false
     // concrete declear for performance purpose
-    const serverRenderedOptions = {
+    const serverRenderedOptions: BindingOption = {
         templateBinding: false,
         textBinding: false,
         cssBinding: false,
@@ -45,23 +68,24 @@ function createBindingOption(condition = '', opt = {}) {
         forOfBinding: false,
         switchBinding: false,
     };
-    let updateOption = {};
+    let updateOption: BindingOption = {};
 
     switch (condition) {
-    case bindingUpdateConditions.serverRendered:
-        updateOption = extend({}, eventsBindingOptions, serverRenderedOptions, opt);
-        break;
-    case bindingUpdateConditions.init:
+        case bindingUpdateConditions.serverRendered:
+            updateOption = extend(false, {}, eventsBindingOptions, serverRenderedOptions, opt);
+            break;
+        case bindingUpdateConditions.init:
         // flag templateBinding to true to render tempalte(s)
-        opt.templateBinding = true;
-        updateOption = extend({}, visualBindingOptions, eventsBindingOptions, opt);
-        break;
-    default:
+            opt.templateBinding = true;
+            opt.forceRender = true;
+            updateOption = extend(false, {}, visualBindingOptions, eventsBindingOptions, opt);
+            break;
+        default:
         // when called again only update visualBinding options
-        updateOption = extend({}, visualBindingOptions, opt);
+            updateOption = extend(false, {}, visualBindingOptions, opt);
     }
 
     return updateOption;
-}
+};
 
 export default createBindingOption;

package/src/createEventBinding.ts

@@ -0,0 +1,88 @@
+import {
+    getFormData,
+    getViewModelValue,
+    resolveViewModelContext,
+    resolveParamList,
+} from './util';
+import type {BindingCache, ViewModel} from './types';
+
+/**
+ * Create event handler wrapper
+ */
+const createEventHandlerWrapper = (
+    type: string,
+    paramList: unknown[],
+    handlerFn: Function,
+    viewModelContext: ViewModel,
+): EventListener => {
+    return function handlerWrap(e: Event): void {
+        let formData: Record<string, unknown>;
+        let args: unknown[] = [];
+        if (type === 'submit') {
+            formData = getFormData(e.currentTarget as HTMLFormElement);
+            args = [e, e.currentTarget, formData, ...paramList];
+        } else {
+            args = [e, e.currentTarget, ...paramList];
+        }
+        handlerFn.apply(viewModelContext, args);
+    };
+};
+
+interface CreateEventBindingParams {
+    cache?: BindingCache;
+    forceRender?: boolean;
+    type?: string;
+    viewModel?: ViewModel;
+}
+
+const createEventBinding = ({
+    cache = {} as BindingCache,
+    forceRender = false,
+    type = '',
+    viewModel = {} as ViewModel,
+}: CreateEventBindingParams): void => {
+    const handlerName = cache.dataKey;
+    let paramList = cache.parameters;
+    let viewModelContext: ViewModel;
+    const APP = viewModel.APP || viewModel.$root?.APP;
+    const rootElement = APP?.$rootElement as HTMLElement | undefined;
+
+    if (!type || !handlerName || (!forceRender && rootElement && !rootElement.contains(cache.el))) {
+        return;
+    }
+
+    const handlerFn = getViewModelValue(viewModel, handlerName);
+
+    if (typeof handlerFn === 'function') {
+        viewModelContext = resolveViewModelContext(viewModel, handlerName);
+        paramList = paramList ? resolveParamList(viewModel, paramList) : [];
+
+        // Store handler key for this event type on the DOM element itself
+        // This prevents duplicate handlers even if multiple cache objects exist for same element
+        const handlerKey = `_db_${type}Handler`;
+        const el = cache.el as HTMLElement & Record<string, unknown>;
+
+        // Check if handler already exists and skip if it's the same
+        // This prevents adding duplicate handlers when the same element is processed multiple times
+        if (el[handlerKey]) {
+            // Handler already exists, remove it before adding new one
+            el.removeEventListener(type, el[handlerKey] as EventListener, false);
+        }
+
+        // Create new handler wrapper
+        const handlerWrap = createEventHandlerWrapper(
+            type,
+            paramList,
+            handlerFn,
+            viewModelContext,
+        );
+
+        // Store the handler on the DOM element so we can remove it later
+        el[handlerKey] = handlerWrap;
+
+        // Add the new event listener
+        el.addEventListener(type, handlerWrap, false);
+    }
+};
+
+export default createEventBinding;

package/src/{cssBinding.js → cssBinding.ts}

@@ -4,6 +4,7 @@ import {
     arrayRemoveMatch,
     each,
 } from './util';
+import type {BindingCache, ViewModel, BindingAttrs, PlainObject} from './types';
 
 /**
  * cssBinding
@@ -16,11 +17,11 @@ import {
  * @param {object} bindingAttrs
  * @param {boolean} forceRender
  */
-const cssBinding = (cache, viewModel, bindingAttrs, forceRender) => {
+const cssBinding = (cache: BindingCache, viewModel: ViewModel, bindingAttrs: BindingAttrs, forceRender: boolean): void => {
     const dataKey = cache.dataKey;
-    const APP = viewModel.APP || viewModel.$root.APP;
+    const APP = viewModel.APP || viewModel.$root?.APP;
 
-    if (!dataKey || (!forceRender && !APP.$rootElement.contains(cache.el))) {
+    if (!dataKey || (!forceRender && !(APP?.$rootElement as HTMLElement)?.contains(cache.el))) {
         return;
     }
 
@@ -30,10 +31,10 @@ const cssBinding = (cache, viewModel, bindingAttrs, forceRender) => {
     const oldCssList = cache.elementData.viewModelPropValue;
     let newCssList = '';
     const vmCssListObj = getViewModelPropValue(viewModel, cache);
-    let vmCssListArray = [];
+    let vmCssListArray: string[] = [];
     let isViewDataObject = false;
     let isViewDataString = false;
-    let cssList = [];
+    let cssList: string[] = [];
 
     if (typeof vmCssListObj === 'string') {
         isViewDataString = true;
@@ -47,7 +48,7 @@ const cssBinding = (cache, viewModel, bindingAttrs, forceRender) => {
     if (isViewDataObject) {
         newCssList = JSON.stringify(vmCssListObj);
     } else {
-        newCssList = vmCssListObj.replace(/\s\s+/g, ' ').trim();
+        newCssList = (vmCssListObj as string).replace(/\s\s+/g, ' ').trim();
         vmCssListArray = newCssList.split(' ');
     }
     // reject if nothing changed
@@ -64,7 +65,7 @@ const cssBinding = (cache, viewModel, bindingAttrs, forceRender) => {
     }
 
     if (isViewDataObject) {
-        each(vmCssListObj, function(k, v) {
+        each(vmCssListObj as PlainObject, (k: string, v: unknown) => {
             const i = cssList.indexOf(k);
             if (v === true) {
                 cssList.push(k);
@@ -74,20 +75,21 @@ const cssBinding = (cache, viewModel, bindingAttrs, forceRender) => {
         });
     } else if (isViewDataString) {
         // remove oldCssList items from cssList
-        cssList = arrayRemoveMatch(cssList, oldCssList);
+        const oldCssArray = typeof oldCssList === 'string' && oldCssList ? oldCssList.split(' ') : [];
+        cssList = arrayRemoveMatch(cssList, oldCssArray) as string[];
         cssList = cssList.concat(vmCssListArray);
     }
 
     // unique cssList array
-    cssList = cssList.filter((v, i, a) => {
+    cssList = cssList.filter((v: string, i: number, a: string[]) => {
         return a.indexOf(v) === i;
     });
 
-    cssList = cssList.join(' ');
+    const cssListString = cssList.join(' ');
     // update element data
     cache.elementData.viewModelPropValue = newCssList;
     // replace all css classes
-    cache.el.setAttribute('class', cssList);
+    cache.el.setAttribute('class', cssListString);
 };
 
 export default cssBinding;

package/src/{domWalker.js → domWalker.ts}

@@ -1,7 +1,8 @@
 import {invertObj, extractFilterList, getFunctionParameterList, REGEX} from './util';
 import {constants} from './config';
+import type {PlainObject, BindingAttrs, ElementCache, BindingCache} from './types';
 
-let bindingAttrsMap;
+let bindingAttrsMap: PlainObject | undefined;
 
 /**
  * walkDOM
@@ -10,47 +11,52 @@ let bindingAttrsMap;
  * @param {object} node
  * @param {function} func
  */
-const walkDOM = (node, func) => {
+const walkDOM = (node: HTMLElement, func: (node: HTMLElement) => boolean): void => {
     let parseChildNode = true;
-    node = node.firstElementChild;
-    while (node) {
-        parseChildNode = func(node);
+    let currentNode = node.firstElementChild as HTMLElement | null;
+    while (currentNode) {
+        parseChildNode = func(currentNode);
         if (parseChildNode) {
-            walkDOM(node, func);
+            walkDOM(currentNode, func);
         }
-        node = node.nextElementSibling;
+        currentNode = currentNode.nextElementSibling as HTMLElement | null;
     }
 };
 
-const getAttributesObject = (node) => {
-    const ret = {};
-    Array.prototype.slice.call(node.attributes).forEach((item) => {
+const getAttributesObject = (node: HTMLElement): PlainObject => {
+    const ret: PlainObject = {};
+    Array.prototype.slice.call(node.attributes).forEach((item: Attr) => {
         ret[item.name] = item.value;
     });
     return ret;
 };
 
-const checkSkipChildParseBindings = (attrObj = {}, bindingAttrs) => {
-    return [bindingAttrs.forOf, bindingAttrs.if, bindingAttrs.case, bindingAttrs.default].filter((type) => {
+const checkSkipChildParseBindings = (attrObj: PlainObject = {}, bindingAttrs: BindingAttrs): string[] => {
+    return [bindingAttrs.forOf, bindingAttrs.if, bindingAttrs.case, bindingAttrs.default].filter((type: string) => {
         return typeof attrObj[type] !== 'undefined';
     });
 };
 
-const rootSkipCheck = (node) => {
+const rootSkipCheck = (node: HTMLElement): boolean => {
     return node.tagName === 'SVG';
 };
 
-const defaultSkipCheck = (node, bindingAttrs) => {
+const defaultSkipCheck = (node: HTMLElement, bindingAttrs: BindingAttrs): boolean => {
     return node.tagName === 'SVG' || node.hasAttribute(bindingAttrs.comp);
 };
 
-const populateBindingCache = ({node, attrObj, bindingCache, type}) => {
-    let attrValue;
-    let cacheData;
+const populateBindingCache = ({node, attrObj, bindingCache, type}: {
+    node: HTMLElement;
+    attrObj: PlainObject;
+    bindingCache: ElementCache;
+    type: string;
+}): ElementCache => {
+    let attrValue: string;
+    let cacheData: Partial<BindingCache>;
 
     if (bindingAttrsMap && bindingAttrsMap[type] && typeof attrObj[type] !== 'undefined') {
         bindingCache[type] = bindingCache[type] || [];
-        attrValue = attrObj[type] || '';
+        attrValue = (attrObj[type] as string) || '';
 
         if (attrValue) {
             attrValue = attrValue.replace(REGEX.LINE_BREAKS_TABS, '').replace(REGEX.WHITE_SPACES, ' ').trim();
@@ -67,28 +73,36 @@ const populateBindingCache = ({node, attrObj, bindingCache, type}) => {
         // populate cacheData.parameters
         // for store function call parameters eg. '$index', '$root'
         // useful with DOM for-loop template as reference to binding data
-        const paramList = getFunctionParameterList(cacheData.dataKey);
+        const paramList = getFunctionParameterList(cacheData.dataKey || '');
         if (paramList) {
             cacheData.parameters = paramList;
-            cacheData.dataKey = cacheData.dataKey.replace(REGEX.FUNCTION_PARAM, '').trim();
+            cacheData.dataKey = (cacheData.dataKey || '').replace(REGEX.FUNCTION_PARAM, '').trim();
         }
         // store parent array reference to cacheData
         cacheData[constants.PARENT_REF] = bindingCache[type];
-        bindingCache[type].push(cacheData);
+        bindingCache[type].push(cacheData as BindingCache);
     }
     return bindingCache;
 };
 
-const createBindingCache = ({rootNode = null, bindingAttrs = {}, skipCheck, isRenderedTemplate = false}) => {
-    let bindingCache = {};
+const createBindingCache = ({rootNode = null, bindingAttrs = {} as BindingAttrs, skipCheck, isRenderedTemplate = false}: {
+    rootNode?: HTMLElement | null;
+    bindingAttrs?: BindingAttrs;
+    skipCheck?: (node: HTMLElement) => boolean;
+    isRenderedTemplate?: boolean;
+}): ElementCache => {
+    let bindingCache: ElementCache = {};
 
-    if (!rootNode instanceof window.Node) {
+    if (!(rootNode instanceof window.Node)) {
         throw new TypeError('walkDOM: Expected a DOM node');
     }
 
     bindingAttrsMap = bindingAttrsMap || invertObj(bindingAttrs);
 
-    const parseNode = (node, skipNodeCheckFn = defaultSkipCheck) => {
+    const parseNode = (
+        node: HTMLElement,
+        skipNodeCheckFn: (node: HTMLElement, bindingAttrs: BindingAttrs) => boolean = defaultSkipCheck,
+    ): boolean => {
         let isSkipForOfChild = false;
 
         if (node.nodeType !== 1 || !node.hasAttributes()) {
@@ -102,7 +116,7 @@ const createBindingCache = ({rootNode = null, bindingAttrs = {}, skipCheck, isRe
         // skip same element that has forOf binding the  forOf is alredy parsed
         const attrObj = getAttributesObject(node);
         const hasSkipChildParseBindings = checkSkipChildParseBindings(attrObj, bindingAttrs);
-        let iterateList = [];
+        let iterateList: string[] = [];
 
         if (hasSkipChildParseBindings.length) {
             isSkipForOfChild = true;
@@ -114,13 +128,13 @@ const createBindingCache = ({rootNode = null, bindingAttrs = {}, skipCheck, isRe
             iterateList = Object.keys(attrObj);
         }
 
-        iterateList.forEach((key) => {
+        iterateList.forEach((key: string) => {
             // skip for switch case and default bining
             if (key !== bindingAttrs.case && key !== bindingAttrs.default) {
                 bindingCache = populateBindingCache({
-                    node: node,
-                    attrObj: attrObj,
-                    bindingCache: bindingCache,
+                    node,
+                    attrObj,
+                    bindingCache,
                     type: key,
                 });
             }