@gogocat/data-bind 1.11.0 → 2.0.0

package/src/createBindingOption.ts

@@ -0,0 +1,91 @@
+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
+ * @param {object} opt
+ * @description
+ * generate binding update option object by condition
+ * @return {object} updateOption
+ */
+const createBindingOption = (condition: string = '', opt: BindingOption = {}): BindingOption => {
+    const visualBindingOptions: BindingOption = {
+        templateBinding: false,
+        textBinding: true,
+        cssBinding: true,
+        ifBinding: true,
+        showBinding: true,
+        modelBinding: true,
+        attrBinding: true,
+        forOfBinding: true,
+        switchBinding: true,
+    };
+    const eventsBindingOptions: BindingOption = {
+        changeBinding: true,
+        clickBinding: true,
+        dblclickBinding: true,
+        blurBinding: true,
+        focusBinding: true,
+        hoverBinding: true,
+        inputBinding: true,
+        submitBinding: true,
+    };
+    // this is visualBindingOptions but everything false
+    // concrete declear for performance purpose
+    const serverRenderedOptions: BindingOption = {
+        templateBinding: false,
+        textBinding: false,
+        cssBinding: false,
+        ifBinding: false,
+        showBinding: false,
+        modelBinding: false,
+        attrBinding: false,
+        forOfBinding: false,
+        switchBinding: false,
+    };
+    let updateOption: BindingOption = {};
+
+    switch (condition) {
+        case bindingUpdateConditions.serverRendered:
+            updateOption = extend(false, {}, eventsBindingOptions, serverRenderedOptions, opt);
+            break;
+        case bindingUpdateConditions.init:
+        // flag templateBinding to true to render tempalte(s)
+            opt.templateBinding = true;
+            opt.forceRender = true;
+            updateOption = extend(false, {}, visualBindingOptions, eventsBindingOptions, opt);
+            break;
+        default:
+        // when called again only update visualBinding options
+            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,
                 });
             }

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

@@ -1,6 +1,7 @@
 import {maxDatakeyLength} from './config';
 import {REGEX} from './util';
 import renderForOfBinding from './renderForOfBinding';
+import type {BindingCache, ViewModel, BindingAttrs} from './types';
 
 /**
  * forOfBinding
@@ -10,7 +11,7 @@ import renderForOfBinding from './renderForOfBinding';
  * @param {object} viewModel
  * @param {object} bindingAttrs
  */
-const forOfBinding = (cache, viewModel, bindingAttrs) => {
+const forOfBinding = (cache: BindingCache, viewModel: ViewModel, bindingAttrs: BindingAttrs, _forceRender?: boolean): void => {
     const dataKey = cache.dataKey;
 
     if (!dataKey || dataKey.length > maxDatakeyLength) {
@@ -42,8 +43,8 @@ const forOfBinding = (cache, viewModel, bindingAttrs) => {
 
     renderForOfBinding({
         bindingData: cache,
-        viewModel: viewModel,
-        bindingAttrs: bindingAttrs,
+        viewModel,
+        bindingAttrs,
     });
 };
 

package/src/hoverBinding.ts

@@ -0,0 +1,84 @@
+
+import {bindingDataReference} from './config';
+import {
+    getViewModelValue,
+    resolveViewModelContext,
+    resolveParamList,
+} from './util';
+import type {BindingCache, ViewModel, BindingAttrs, PlainObject} from './types';
+
+/**
+ * Create mouse enter handler
+ */
+const createMouseEnterHandler = (
+    cache: BindingCache,
+    handlers: PlainObject,
+    inHandlerName: string,
+    viewModelContext: ViewModel,
+    paramList: unknown[],
+): (e: MouseEvent) => void => {
+    return function onMouseEnterHandler(e: MouseEvent) {
+        const args = [e, cache.el, ...paramList];
+        (handlers[inHandlerName] as Function).apply(viewModelContext, args);
+    };
+};
+
+/**
+ * Create mouse leave handler
+ */
+const createMouseLeaveHandler = (
+    cache: BindingCache,
+    handlers: PlainObject,
+    outHandlerName: string,
+    viewModelContext: ViewModel,
+    paramList: unknown[],
+): (e: MouseEvent) => void => {
+    return function onMouseLeaveHandler(e: MouseEvent) {
+        const args = [e, cache.el, ...paramList];
+        (handlers[outHandlerName] as Function).apply(viewModelContext, args);
+    };
+};
+
+/**
+ * hoverBinding
+ * DOM decleartive on hover event binding
+ * event handler bind to viewModel method according to the DOM attribute
+ * @param {object} cache
+ * @param {object} viewModel
+ * @param {object} bindingAttrs
+ * @param {boolean} forceRender
+ */
+const hoverBinding = (cache: BindingCache, viewModel: ViewModel, bindingAttrs: BindingAttrs, forceRender: boolean): void => {
+    const handlerName = cache.dataKey;
+    let paramList = cache.parameters;
+    const inHandlerName = bindingDataReference.mouseEnterHandlerName;
+    const outHandlerName = bindingDataReference.mouseLeaveHandlerName;
+    let viewModelContext: ViewModel;
+    const APP = viewModel.APP || viewModel.$root?.APP;
+
+    cache.elementData = cache.elementData || {};
+
+    // TODO: check what is APP.$rootElement.contains(cache.el)
+    const rootElement = APP?.$rootElement as HTMLElement | undefined;
+    if (!handlerName || (!forceRender && rootElement && !rootElement.contains(cache.el))) {
+        return;
+    }
+
+    const handlers = getViewModelValue(viewModel, handlerName) as PlainObject;
+
+    if (handlers && typeof handlers[inHandlerName] === 'function' && typeof handlers[outHandlerName] === 'function') {
+        viewModelContext = resolveViewModelContext(viewModel, handlerName);
+        paramList = paramList ? resolveParamList(viewModel, paramList) : [];
+
+        const onMouseEnterHandler = createMouseEnterHandler(cache, handlers as PlainObject, inHandlerName, viewModelContext, paramList);
+        const onMouseLeaveHandler = createMouseLeaveHandler(cache, handlers as PlainObject, outHandlerName, viewModelContext, paramList);
+
+        cache.el.removeEventListener('mouseenter', onMouseEnterHandler, false);
+        cache.el.removeEventListener('mouseleave', onMouseLeaveHandler, false);
+
+        cache.el.addEventListener('mouseenter', onMouseEnterHandler, false);
+        cache.el.addEventListener('mouseleave', onMouseLeaveHandler, false);
+    }
+};
+
+export default hoverBinding;

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

@@ -2,6 +2,7 @@ import {bindingAttrs as configBindingAttrs, constants} from './config';
 import {getViewModelPropValue, removeElement} from './util';
 import {createClonedElementCache, wrapCommentAround} from './commentWrapper';
 import {renderIfBinding, removeIfBinding} from './renderIfBinding';
+import type {BindingCache, ViewModel, BindingAttrs} from './types';
 
 /**
  * if-Binding
@@ -11,7 +12,7 @@ import {renderIfBinding, removeIfBinding} from './renderIfBinding';
  * @param {object} viewModel
  * @param {object} bindingAttrs
  */
-const ifBinding = (cache, viewModel, bindingAttrs) => {
+const ifBinding = (cache: BindingCache, viewModel: ViewModel, bindingAttrs: BindingAttrs, _forceRender?: boolean): void => {
     const dataKey = cache.dataKey;
 
     // isOnce only return if there is no child bindings
@@ -38,8 +39,8 @@ const ifBinding = (cache, viewModel, bindingAttrs) => {
         removeElement(cache.el);
         // delete cache.fragment;
         removeBindingInQueue({
-            viewModel: viewModel,
-            cache: cache,
+            viewModel,
+            cache,
         });
         return;
     }
@@ -63,8 +64,8 @@ const ifBinding = (cache, viewModel, bindingAttrs) => {
         // render element
         renderIfBinding({
             bindingData: cache,
-            viewModel: viewModel,
-            bindingAttrs: bindingAttrs,
+            viewModel,
+            bindingAttrs,
         });
 
         // if render once
@@ -72,20 +73,21 @@ const ifBinding = (cache, viewModel, bindingAttrs) => {
         if (cache.isOnce && !cache.hasIterationBindingCache) {
             // delete cache.fragment;
             removeBindingInQueue({
-                viewModel: viewModel,
-                cache: cache,
+                viewModel,
+                cache,
             });
         }
     }
 };
 
-const removeBindingInQueue = ({viewModel, cache}) => {
+const removeBindingInQueue = ({viewModel, cache}: {viewModel: ViewModel; cache: BindingCache}): boolean => {
     let ret = false;
-    if (viewModel.APP.postProcessQueue) {
+    if (viewModel.APP?.postProcessQueue) {
+        const parentRef = cache[constants.PARENT_REF] as BindingCache[];
         viewModel.APP.postProcessQueue.push(
-            ((cache, index) => () => {
-                cache[constants.PARENT_REF].splice(index, 1);
-            })(cache, cache[constants.PARENT_REF].indexOf(cache)),
+            ((cache: BindingCache, index: number) => () => {
+                parentRef.splice(index, 1);
+            })(cache, parentRef.indexOf(cache)),
         );
         ret = true;
     }

package/src/index.ts

@@ -0,0 +1,53 @@
+import * as config from './config';
+import {extend} from './util';
+import Binder from './binder';
+import type {PlainObject, ViewModel, BindingAttrs, BinderOptions} from './types';
+
+const isSupportPromise = typeof window['Promise'] === 'function';
+
+let bindingAttrs = config.bindingAttrs;
+
+// Global default options for all Binder instances
+const defaultOptions: BinderOptions = {
+    reactive: true, // Enable reactive mode by default
+};
+
+interface DataBindAPI {
+    use: (settings: PlainObject) => DataBindAPI;
+    init: ($rootElement: HTMLElement, viewModel: ViewModel | null, options?: BinderOptions) => Binder | void;
+    version: string;
+}
+
+const use = (settings: PlainObject = {}): DataBindAPI => {
+    if (settings.bindingAttrs) {
+        bindingAttrs = extend(false, {}, settings.bindingAttrs as PlainObject) as unknown as typeof config.bindingAttrs;
+    }
+    // Allow setting global reactive option
+    if (typeof settings.reactive === 'boolean') {
+        defaultOptions.reactive = settings.reactive;
+    }
+    // Allow setting global trackChanges option
+    if (typeof settings.trackChanges === 'boolean') {
+        defaultOptions.trackChanges = settings.trackChanges;
+    }
+    // Return API for chaining
+    return api;
+};
+
+const init = ($rootElement: HTMLElement, viewModel: ViewModel | null = null, options?: BinderOptions): Binder | void => {
+    if (!isSupportPromise) {
+        return console.warn('Browser not support Promise');
+    }
+    // Merge global defaults with instance-specific options
+    // Instance options take precedence over global defaults
+    const mergedOptions = {...defaultOptions, ...options};
+    return new Binder($rootElement, viewModel, bindingAttrs as unknown as BindingAttrs, mergedOptions);
+};
+
+const api: DataBindAPI = {
+    use,
+    init,
+    version: '@version@',
+};
+
+export default api;