render-core 1.0.0

package/core/render/apiRender.js

@@ -0,0 +1,60 @@
+import { loadStyle } from "../../library/loader/loader";
+import { addLabel } from "../utility/miscUtility";
+import { getProxyObjectForApi } from "../proxy/getProxy";
+import { ApiController } from "../../class/apiController";
+import { getApiCodeSpace, getCodeSpaceForRef } from "../utility/injectUtility";
+import { findComponent } from "./initRender";
+import { resolver_Ref } from "../cmd/v-ref";
+import { resolver_html } from "../cmd/v-html";
+import { resolver_txt } from "../cmd/v-txt";
+import { resolver_model } from "../cmd/v-model";
+import { resolver_bind } from "../cmd/v-bind";
+import { resolver_event } from "../cmd/v-on";
+//渲染自定义标签
+export function apiRender(proto, parent, attr, tagLib, link) {
+    //获取控制对象
+    var apiController = new ApiController();
+    apiController.proto = proto;
+    //复制原始数据对象到控制对象
+    apiController.raw_data = Object.create(proto.getData());
+    //数据渲染对象
+    apiController.proxyForMethods = getProxyObjectForApi(apiController.raw_data, apiController);
+    //beforeRender
+    var beforeRender = proto.getBeforeRender().bind(apiController.raw_data);
+    beforeRender();
+    //Render
+    var temp = document.createElement("div");
+    temp.innerHTML = proto.getTemplate();
+    var template = temp.getElementsByTagName("template")[0];
+    var content = template.content;
+    //获取到模板
+    var tagTemplate = content.firstElementChild;
+    addLabel(tagTemplate.children, proto.getName());
+    resolver_event(tagTemplate.children, proto.getMethods(), apiController.proxyForMethods);
+    resolver_html(tagTemplate.children, apiController.proxyForMethods);
+    resolver_txt(tagTemplate.children, apiController.proxyForMethods);
+    resolver_model(tagTemplate.children, apiController.proxyForMethods);
+    resolver_bind(tagTemplate.children, apiController.proxyForMethods);
+    //获取到模板样式
+    var tagStyle = content.lastElementChild;
+    loadStyle(tagStyle.childNodes[0].nodeValue, proto.getName());
+    //注入ref
+    getCodeSpaceForRef(apiController.raw_data, resolver_Ref(tagTemplate.children));
+    //mount
+    while (parent.hasChildNodes()) {
+        parent.removeChild(parent.firstChild);
+    }
+    while (tagTemplate.hasChildNodes()) {
+        parent.append(tagTemplate.firstChild);
+    }
+    //afterRender
+    var afterRender = proto.getAfterRender().bind(apiController.raw_data);
+    afterRender();
+    //切换根组件
+    apiController.root = parent;
+    //深度渲染
+    findComponent(tagTemplate.children, tagLib, link);
+    //返回api对象
+    getApiCodeSpace(apiController.raw_data, proto.getMethods());
+    return apiController.raw_data;
+}

package/core/render/depthRender.d.ts

@@ -0,0 +1,5 @@
+import { Controller } from "../../class/controller";
+import { Component } from "../../class/component";
+import { ApiController } from "../../class/apiController";
+export declare function depthRender(proto: Component, parent: ParentNode, child: Element, tagLib: Map<string, Component>, link: Controller | ApiController): void;
+export declare function depthFindComponent(collection: HTMLCollection, tagLib: Map<string, Component>, link: Controller | ApiController): void;

package/core/render/depthRender.js

@@ -0,0 +1,198 @@
+import { loadStyle } from "../../library/loader/loader";
+import { addLabel } from "../utility/miscUtility";
+import { getProxyForInject, getProxyObject } from "../proxy/getProxy";
+import { Controller } from "../../class/controller";
+import { getCodeSpaceForCommit, getCodeSpaceForProps, getCodeSpaceForPublish, getCodeSpaceForQuery, getCodeSpaceForRef, getCommitMethod, getPublishMethod, } from "../utility/injectUtility";
+import { resolveProps } from "../resolver/props";
+import { resolve_Queries, } from "../resolver/query";
+import { resolver_event } from "../cmd/v-on";
+import { resolver_html } from "../cmd/v-html";
+import { resolver_txt } from "../cmd/v-txt";
+import { resolver_model } from "../cmd/v-model";
+import { resolver_Ref } from "../cmd/v-ref";
+import { isUnKnown } from "../utility/checkUtility";
+import { resolver_bind } from "../cmd/v-bind";
+//渲染自定义标签
+export function depthRender(proto, parent, child, tagLib, link) {
+    //生成DOM
+    var temp = document.createElement("div");
+    temp.innerHTML = proto.getTemplate();
+    var template = temp.getElementsByTagName("template")[0];
+    var content = template.content;
+    //获得模板元素
+    var tagTemplate = content.firstElementChild;
+    //解析元素上的静态属性
+    var props = resolveProps(tagTemplate, proto);
+    //获得模板样式元素
+    var tagStyle = content.lastElementChild;
+    //向head位置添加该组件的样式
+    loadStyle(tagStyle.childNodes[0].nodeValue, proto.getName());
+    //两种渲染方式
+    if (child.hasAttribute("name")) {
+        if (link.link.has(child.getAttribute("name"))) {
+            //获取控制对象
+            var controller = new Controller();
+            controller.proto = proto;
+            //复制原始数据对象到控制对象
+            controller.raw_data = link.link.get(child.getAttribute("name"));
+            //注入props
+            getCodeSpaceForProps(controller.raw_data, resolveProps(tagTemplate.firstElementChild, controller.proto.getProps()));
+            //注入query
+            getCodeSpaceForQuery(controller.raw_data, resolve_Queries());
+            //注入ref
+            getCodeSpaceForRef(controller.raw_data, resolver_Ref(tagTemplate.children));
+            //数据渲染对象
+            controller.proxyForMethods = getProxyObject(controller.raw_data, controller);
+            //注入commit
+            getCodeSpaceForCommit(controller.raw_data, getCommitMethod(link));
+            //注入receiver
+            getCodeSpaceForPublish(controller.raw_data, getPublishMethod(controller));
+            //beforeRender
+            var beforeRender = proto.getBeforeRender().bind(controller.raw_data);
+            beforeRender();
+            //给所有元素添加上npm=tag标志
+            addLabel(tagTemplate.children, proto.getName());
+            //将元素事件绑定到元素上
+            resolver_event(tagTemplate.children, proto.getMethods(), controller.proxyForMethods);
+            //渲染html
+            resolver_html(tagTemplate.children, controller.proxyForMethods);
+            //渲染text
+            resolver_txt(tagTemplate.children, controller.proxyForMethods);
+            //绑定数据
+            resolver_model(tagTemplate.children, controller.proxyForMethods);
+            //渲染属性
+            resolver_bind(tagTemplate.children, controller.proxyForMethods);
+            //beforeMount
+            var beforeMount = proto.getBeforeMount().bind(controller.raw_data);
+            beforeMount();
+            //mount
+            var renderSpace = document.createElement("div");
+            parent.replaceChild(renderSpace, child);
+            while (tagTemplate.hasChildNodes()) {
+                renderSpace.append(tagTemplate.firstChild);
+            }
+            //afterRender
+            var afterRender = proto.getAfterRender().bind(controller.raw_data);
+            afterRender();
+            //指定渲染空间
+            controller.root = renderSpace;
+            link.to.push(controller);
+            //深度渲染
+            depthFindComponent(tagTemplate.children, tagLib, controller);
+        }
+        else {
+            //获取控制对象
+            var controller = new Controller();
+            controller.proto = proto;
+            controller.preRender = true;
+            //复制原始数据对象到控制对象
+            controller.raw_data = Object.create(proto.getData());
+            //注入props
+            getCodeSpaceForProps(controller.raw_data, resolveProps(tagTemplate.firstElementChild, controller.proto.getProps()));
+            //注入query
+            getCodeSpaceForQuery(controller.raw_data, resolve_Queries());
+            //注入ref
+            getCodeSpaceForRef(controller.raw_data, resolver_Ref(tagTemplate.children));
+            //数据渲染对象
+            controller.proxyForMethods = getProxyObject(controller.raw_data, controller);
+            getCodeSpaceForCommit(controller.raw_data, getCommitMethod(link));
+            //注入receiver
+            getCodeSpaceForPublish(controller.raw_data, getPublishMethod(controller));
+            //beforeRender
+            var beforeRender = proto.getBeforeRender().bind(controller.raw_data);
+            beforeRender();
+            //给所有元素添加上npm=tag标志
+            addLabel(tagTemplate.children, proto.getName());
+            //将元素事件绑定到元素上
+            resolver_event(tagTemplate.children, proto.getMethods(), controller.proxyForMethods);
+            //渲染html
+            resolver_html(tagTemplate.children, controller.proxyForMethods);
+            //渲染text
+            resolver_txt(tagTemplate.children, controller.proxyForMethods);
+            //绑定数据
+            resolver_model(tagTemplate.children, controller.proxyForMethods);
+            //渲染属性
+            resolver_bind(tagTemplate.children, controller.proxyForMethods);
+            //beforeMount
+            var beforeMount = proto.getBeforeMount().bind(controller.raw_data);
+            beforeMount();
+            //mount
+            var renderSpace = document.createElement("div");
+            controller.root = renderSpace;
+            parent.replaceChild(renderSpace, child);
+            while (tagTemplate.hasChildNodes()) {
+                renderSpace.append(tagTemplate.firstChild);
+            }
+            //afterRender
+            var afterRender = proto.getAfterRender().bind(controller.raw_data);
+            afterRender();
+            if (controller.preRender) {
+                link.link.set(child.getAttribute("name"), controller.raw_data);
+            }
+            link.to.push(controller);
+            //深度渲染
+            depthFindComponent(controller.root.children, tagLib, controller);
+        }
+    }
+    else {
+        //获取控制对象
+        var controller = new Controller();
+        controller.proto = proto;
+        //复制原始数据对象到控制对象
+        controller.raw_data = Object.create(proto.getData());
+        //数据渲染对象
+        controller.proxyForMethods = getProxyObject(controller.raw_data, controller);
+        //注入commit
+        getCodeSpaceForCommit(controller.raw_data, getCommitMethod(link));
+        //注入receiver
+        getCodeSpaceForPublish(controller.raw_data, getPublishMethod(controller));
+        //beforeRender
+        var beforeRender = proto.getBeforeRender().bind(controller.raw_data);
+        beforeRender();
+        //注入props
+        getCodeSpaceForProps(controller.raw_data, getProxyForInject(props));
+        //注入query
+        getCodeSpaceForQuery(controller.raw_data, resolve_Queries());
+        //注入ref
+        getCodeSpaceForRef(controller.raw_data, resolver_Ref(tagTemplate.children));
+        //给所有元素添加上npm=tag标志
+        addLabel(tagTemplate.children, proto.getName());
+        //将元素事件绑定到元素上
+        resolver_event(tagTemplate.children, proto.getMethods(), controller.proxyForMethods);
+        //渲染html
+        resolver_html(tagTemplate.children, controller.proxyForMethods);
+        //渲染text
+        resolver_txt(tagTemplate.children, controller.proxyForMethods);
+        //绑定数据
+        resolver_model(tagTemplate.children, controller.proxyForMethods);
+        //渲染属性
+        resolver_bind(tagTemplate.children, controller.proxyForMethods);
+        //beforeMount
+        var beforeMount = proto.getBeforeMount().bind(controller.raw_data);
+        beforeMount();
+        //mount
+        var renderSpace = document.createElement("div");
+        controller.root = renderSpace;
+        parent.replaceChild(renderSpace, child);
+        while (tagTemplate.hasChildNodes()) {
+            renderSpace.append(tagTemplate.firstChild);
+        }
+        //afterRender
+        var afterRender = proto.getAfterRender().bind(controller.raw_data);
+        afterRender();
+        link.to.push(controller);
+        //深度渲染
+        depthFindComponent(controller.root.children, tagLib, controller);
+    }
+}
+//继续渲染
+export function depthFindComponent(collection, tagLib, link) {
+    for (var i = 0; i < collection.length; i++) {
+        if (isUnKnown(collection[i].nodeName)) {
+            depthRender(tagLib.get(collection[i].nodeName.toUpperCase()), collection[i].parentNode, collection[i], tagLib, link);
+        }
+        else {
+            depthFindComponent(collection[i].children, tagLib, link);
+        }
+    }
+}

package/core/render/initRender.d.ts

@@ -0,0 +1,5 @@
+import { Controller } from "../../class/controller";
+import { Component } from "../../class/component";
+import { ApiController } from "../../class/apiController";
+export declare function initRender(proto: Component, parent: ParentNode, child: Element, tagLib: Map<string, Component>): void;
+export declare function findComponent(collection: HTMLCollection, tagLib: Map<string, Component>, link: Controller | ApiController): void;

package/core/render/initRender.js

@@ -0,0 +1,87 @@
+import { loadStyle } from "../../library/loader/loader";
+import { addLabel } from "../utility/miscUtility";
+import { getProxyObject } from "../proxy/getProxy";
+import { Controller } from "../../class/controller";
+import { getCodeSpaceForProps, getCodeSpaceForPublish, getCodeSpaceForQuery, getCodeSpaceForRef, getPublishMethod } from "../utility/injectUtility";
+import { resolveProps } from "../resolver/props";
+import { resolve_Queries } from "../resolver/query";
+import { resolver_event } from "../cmd/v-on";
+import { resolver_html } from "../cmd/v-html";
+import { resolver_txt } from "../cmd/v-txt";
+import { resolver_model } from "../cmd/v-model";
+import { resolver_Ref } from "../cmd/v-ref";
+import { isUnKnown } from "../utility/checkUtility";
+import { resolver_bind } from "../cmd/v-bind";
+import { depthRender } from "./depthRender";
+//渲染自定义标签
+export function initRender(proto, parent, child, tagLib) {
+    //生成DOM
+    var temp = document.createElement("div");
+    temp.innerHTML = proto.getTemplate();
+    var template = temp.getElementsByTagName("template")[0];
+    var content = template.content;
+    //获得模板元素
+    var tagTemplate = content.firstElementChild;
+    //解析元素上的静态属性
+    var props = resolveProps(tagTemplate, proto);
+    //获得模板样式元素
+    var tagStyle = content.lastElementChild;
+    //向head位置添加该组件的样式
+    loadStyle(tagStyle.childNodes[0].nodeValue, proto.getName());
+    //获取控制对象
+    var controller = new Controller();
+    controller.proto = proto;
+    //复制原始数据对象到控制对象
+    controller.raw_data = Object.create(proto.getData());
+    //注入props
+    getCodeSpaceForProps(controller.raw_data, resolveProps(tagTemplate.firstElementChild, controller.proto.getProps()));
+    //注入query
+    getCodeSpaceForQuery(controller.raw_data, resolve_Queries());
+    //注入ref
+    getCodeSpaceForRef(controller.raw_data, resolver_Ref(tagTemplate.children));
+    //数据渲染对象
+    controller.proxyForMethods = getProxyObject(controller.raw_data, controller);
+    //注入receiver
+    getCodeSpaceForPublish(controller.raw_data, getPublishMethod(controller));
+    //beforeRender
+    var beforeRender = proto.getBeforeRender().bind(controller.raw_data);
+    beforeRender();
+    //给所有元素添加上npm=tag标志
+    addLabel(tagTemplate.children, proto.getName());
+    //将元素事件绑定到元素上
+    resolver_event(tagTemplate.children, proto.getMethods(), controller.proxyForMethods);
+    //渲染html
+    resolver_html(tagTemplate.children, controller.proxyForMethods);
+    //渲染text
+    resolver_txt(tagTemplate.children, controller.proxyForMethods);
+    //绑定数据
+    resolver_model(tagTemplate.children, controller.proxyForMethods);
+    //渲染属性
+    resolver_bind(tagTemplate.children, controller.proxyForMethods);
+    //beforeMount
+    var beforeMount = proto.getBeforeMount().bind(controller.raw_data);
+    beforeMount();
+    //mount
+    var renderSpace = document.createElement("div");
+    controller.root = renderSpace;
+    parent.replaceChild(renderSpace, child);
+    while (tagTemplate.hasChildNodes()) {
+        renderSpace.append(tagTemplate.firstChild);
+    }
+    //afterRender
+    var afterRender = proto.getAfterRender().bind(controller.raw_data);
+    afterRender();
+    //深度渲染
+    findComponent(controller.root.children, tagLib, controller);
+}
+//继续渲染
+export function findComponent(collection, tagLib, link) {
+    for (var i = 0; i < collection.length; i++) {
+        if (isUnKnown(collection[i].nodeName)) {
+            depthRender(tagLib.get(collection[i].nodeName.toUpperCase()), collection[i].parentNode, collection[i], tagLib, link);
+        }
+        else {
+            findComponent(collection[i].children, tagLib, link);
+        }
+    }
+}

package/core/render/updateRender.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "../../class/controller";
+export declare function updateRender(updater: Controller): void;

package/core/render/updateRender.js

@@ -0,0 +1,50 @@
+import { resolver_event } from "../cmd/v-on";
+import { resolver_html } from "../cmd/v-html";
+import { resolver_txt } from "../cmd/v-txt";
+import { resolver_bind } from "../cmd/v-bind";
+import { addLabel, bindModelForUpdater } from "../utility/miscUtility";
+import { depthFindComponent } from "./depthRender";
+export function updateRender(updater) {
+    //生成DOM
+    var temp = document.createElement("div");
+    temp.innerHTML = updater.proto.getTemplate();
+    var template = temp.getElementsByTagName("template")[0];
+    var tagTemplate = template.content.children[0];
+    var updateRawData = updater.proxyForMethods;
+    //beforeRender
+    var beforeRender = updater.proto.getBeforeRender().bind(updateRawData);
+    beforeRender();
+    //beforeUpdate
+    var beforeUpdate = updater.proto.getBeforeUpdate().bind(updateRawData);
+    beforeUpdate();
+    //updateRender actions
+    addLabel(tagTemplate.children, updater.proto.getName());
+    resolver_event(tagTemplate.children, updater.proto.getMethods(), updater.proxyForMethods);
+    resolver_html(tagTemplate.children, updater.proxyForMethods);
+    resolver_txt(tagTemplate.children, updater.proxyForMethods);
+    resolver_bind(tagTemplate.children, updater.proxyForMethods);
+    //afterUpdate
+    var afterUpdate = updater.proto.getAfterUpdate().bind(updateRawData);
+    afterUpdate();
+    //beforeUnmount
+    var beforeUnmount = updater.proto.getBeforeUnmount().bind(updateRawData);
+    beforeUnmount();
+    //unmount
+    while (updater.root.hasChildNodes()) {
+        updater.root.removeChild(updater.root.firstChild);
+    }
+    //beforeMount
+    var beforeMount = updater.proto.getBeforeMount().bind(updateRawData);
+    beforeMount();
+    //mount
+    while (tagTemplate.hasChildNodes()) {
+        updater.root.appendChild(tagTemplate.firstChild);
+    }
+    //afterRender
+    var afterRender = updater.proto.getAfterRender().bind(updateRawData);
+    afterRender();
+    //获取定位
+    bindModelForUpdater(updater.root.children, updater.proxyForMethods);
+    //深度渲染
+    depthFindComponent(updater.root.children, Reflect.get(window, "tagLib"), updater);
+}

package/core/resolver/props.d.ts

@@ -0,0 +1 @@
+export declare function resolveProps(node: Element, properties: {} | []): any;

package/core/resolver/props.js

@@ -0,0 +1,14 @@
+import { getProxyForInject } from "../proxy/getProxy";
+export function resolveProps(node, properties) {
+    if (properties instanceof Array) {
+    }
+    if (properties instanceof Object) {
+    }
+    var attrs = node.attributes;
+    var props = new Map();
+    // for (let key  in Object.getOwnPropertyNames(properties)) {
+    //
+    //     props[key] = attrs.getNamedItem(key).value;
+    // }
+    return getProxyForInject(props);
+}

package/core/resolver/query.d.ts

@@ -0,0 +1 @@
+export declare function resolve_Queries(): Map<string, any>;

package/core/resolver/query.js

@@ -0,0 +1,13 @@
+import { getProxyForInject } from "../proxy/getProxy";
+export function resolve_Queries() {
+    var query = new Map();
+    if (location.search !== undefined) {
+        var parameters = location.search.replace("?", "");
+        var listPara = parameters.split("&");
+        listPara.forEach(function (value) {
+            var results = value.split("=");
+            Reflect.set(query, results[0], results[1]);
+        });
+    }
+    return getProxyForInject(query);
+}

package/core/utility/checkUtility.d.ts

@@ -0,0 +1 @@
+export declare function isUnKnown(element: string): boolean;

package/core/utility/checkUtility.js

@@ -0,0 +1,4 @@
+import metaTagLib from "../../runtime/database/metaTagLib";
+export function isUnKnown(element) {
+    return !metaTagLib.some(function (ele) { return ele == element; });
+}

package/core/utility/injectUtility.d.ts

@@ -0,0 +1,10 @@
+import { Controller } from "../../class/controller";
+import { ApiController } from "../../class/apiController";
+export declare function getCodeSpaceForProps(data: {}, $props: {}): void;
+export declare function getCodeSpaceForQuery(data: {}, $query: {}): void;
+export declare function getCodeSpaceForRef(data: {}, $ref: Map<string, Element>): void;
+export declare function getApiCodeSpace(data: {}, method: {}): void;
+export declare function getCommitMethod(controller: Controller | ApiController): any;
+export declare function getCodeSpaceForCommit(data: {}, commit: any): void;
+export declare function getPublishMethod(controller: Controller | ApiController): any;
+export declare function getCodeSpaceForPublish(data: {}, publisher: any): void;

package/core/utility/injectUtility.js

@@ -0,0 +1,47 @@
+export function getCodeSpaceForProps(data, $props) {
+    Reflect.set(data, "$props", $props);
+}
+export function getCodeSpaceForQuery(data, $query) {
+    Reflect.set(data, "$query", $query);
+}
+//注入对象
+export function getCodeSpaceForRef(data, $ref) {
+    Reflect.set(data, "$refs", $ref);
+}
+//注入对象
+export function getApiCodeSpace(data, method) {
+    var list = Object.getOwnPropertyNames(method);
+    list.forEach(function (value) {
+        Reflect.set(data, value, method[value].bind(data));
+    });
+}
+export function getCommitMethod(controller) {
+    var commit = function (method) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.receiver(method, args);
+    };
+    return commit.bind(controller);
+}
+//注入对象
+export function getCodeSpaceForCommit(data, commit) {
+    Reflect.set(data, "$commit", commit);
+}
+export function getPublishMethod(controller) {
+    var publisher = function (method) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        for (var i = 0; i < this.to.length; i++) {
+            this.to[i].receiver(method, args);
+        }
+    };
+    return publisher.bind(controller);
+}
+//注入对象
+export function getCodeSpaceForPublish(data, publisher) {
+    Reflect.set(data, "$publish", publisher);
+}

package/core/utility/miscUtility.d.ts

@@ -0,0 +1,4 @@
+import { Component } from "../../class/component";
+export declare function addLabel(nodes: HTMLCollection, component: string): void;
+export declare function resolver(element: Element, tagLib: Map<string, Component>): void;
+export declare function bindModelForUpdater(nodes: HTMLCollection, data: {}): void;

package/core/utility/miscUtility.js

@@ -0,0 +1,55 @@
+import { initRender } from "../render/initRender";
+export function addLabel(nodes, component) {
+    for (var i = 0; i < nodes.length; i++) {
+        nodes[i].setAttribute("cpn", component);
+        var kk = nodes[i].children;
+        addLabel(kk, component);
+    }
+}
+export function resolver(element, tagLib) {
+    initRender(tagLib.get(element.nodeName.toUpperCase()), element.parentNode, element, tagLib);
+}
+export function bindModelForUpdater(nodes, data) {
+    for (var i = 0; i < nodes.length; i++) {
+        var result = nodes[i].hasAttribute("v-model");
+        if (result) {
+            var dataName = nodes[i].getAttribute("v-model");
+            nodes[i].removeAttribute("v-model");
+            var tagName = nodes[i].tagName;
+            nodes[i].setAttribute("name", dataName);
+            // @ts-ignore
+            nodes[i].setAttribute("value", data[dataName]);
+            if (tagName === "INPUT" || tagName === "SELECT" || tagName === "TEXTAREA") {
+                nodes[i].setAttribute("name", dataName);
+                // @ts-ignore
+                nodes[i].setAttribute("value", data[dataName]);
+                //光标定位
+                var listener = function (evt) {
+                    if (!evt.target.hasAttribute("flag")) {
+                        var element = evt.target;
+                        var dataName_1 = element.name;
+                        this[dataName_1] = element.value;
+                    }
+                };
+                var compositionstart = function (evt) {
+                    evt.target.setAttribute("flag", "false");
+                };
+                var compositionend = function (evt) {
+                    evt.target.setAttribute("flag", "true");
+                    var element = evt.target;
+                    var dataName = element.name;
+                    this[dataName] = element.value;
+                };
+                nodes[i].addEventListener("input", listener.bind(data));
+                nodes[i].addEventListener("compositionstart", compositionstart);
+                nodes[i].addEventListener("compositionend", compositionend.bind(data));
+                // @ts-ignore
+                nodes[i].focus();
+                // @ts-ignore
+                nodes[i].setSelectionRange(data[dataName].length, data[dataName].length);
+            }
+        }
+        var subElements = nodes[i].children;
+        bindModelForUpdater(subElements, data);
+    }
+}

package/core/utility/styleUtility.d.ts

@@ -0,0 +1 @@
+export declare function checkStyleLabel(tag: string): boolean;

package/core/utility/styleUtility.js

@@ -0,0 +1,12 @@
+export function checkStyleLabel(tag) {
+    //获取所有的style标签
+    var styles = document.getElementsByTagName("style");
+    //遍历标签，查看是否已经加载tag样式
+    for (var i = 0; i < styles.length; i++) {
+        if (styles[i].getAttribute("tag") === tag.toUpperCase())
+            //样式已经加载
+            return true;
+    }
+    //样式未加载
+    return false;
+}

package/index.d.ts

@@ -0,0 +1,28 @@
+import { Component } from "./class/component";
+export declare class RenderJS {
+    readonly version: string;
+    readonly tagLib: Map<string, Component>;
+    constructor();
+    addTag(component: Component | Component[]): void;
+    run(): void;
+}
+export declare class EmbedRenderJs {
+    private readonly apiComponent;
+    private controller;
+    constructor(config: {
+        name: string;
+        template: string;
+        data?: {};
+        computed?: {};
+        methods?: {};
+        watcher?: {};
+        beforeRender?: () => void;
+        afterRender?: () => void;
+        beforeUpdate?: () => void;
+        afterUpdate?: () => void;
+        beforeMount?: () => void;
+        beforeUnmount?: () => void;
+    });
+    render(selector: string): void;
+    commit(method: string, ...args: any[]): any;
+}