render-core 1.0.0

package/class/apiComponent.d.ts

@@ -0,0 +1,55 @@
+interface EmbedBase {
+    getName(): string;
+    getTemplate(): string;
+    getData(): {};
+    getComputed(): {};
+    getMethods(): {};
+    getWatcher(): {};
+    getBeforeRender(): () => void;
+    getAfterRender(): () => void;
+    getBeforeUpdate(): () => void;
+    getAfterUpdate(): () => void;
+    getBeforeMount(): () => void;
+    getBeforeUnmount(): () => void;
+}
+export default class ApiComponent implements EmbedBase {
+    private readonly name;
+    private readonly template;
+    private readonly data;
+    private readonly methods?;
+    private readonly computed?;
+    private readonly watcher?;
+    private readonly beforeRender?;
+    private readonly afterRender?;
+    private readonly beforeUpdate?;
+    private readonly afterUpdate?;
+    private readonly beforeMount?;
+    private readonly beforeUnmount?;
+    constructor(config: {
+        name: string;
+        template: string;
+        data?: {};
+        computed?: {};
+        methods?: {};
+        watcher?: {};
+        beforeRender?: () => void;
+        afterRender?: () => void;
+        beforeUpdate?: () => void;
+        afterUpdate?: () => void;
+        beforeMount?: () => void;
+        beforeUnmount?: () => void;
+    });
+    getName(): string;
+    getTemplate(): string;
+    getData(): {};
+    getMethods(): {};
+    getComputed(): {};
+    getWatcher(): {};
+    getBeforeRender(): () => void;
+    getAfterRender(): () => void;
+    getBeforeUpdate(): () => void;
+    getAfterUpdate(): () => void;
+    getBeforeMount(): () => void;
+    getBeforeUnmount(): () => void;
+}
+export {};

package/class/apiComponent.js

@@ -0,0 +1,111 @@
+var ApiComponent = /** @class */ (function () {
+    function ApiComponent(config) {
+        //标签名称
+        this.name = config.name;
+        //标签模板样式
+        this.template = config.template;
+        //添加数据
+        if (typeof config.data == "undefined") {
+            this.data = {};
+        }
+        else {
+            this.data = config.data;
+        }
+        //添加计算属性
+        if (config.computed == "undefined") {
+            this.computed = {};
+        }
+        else {
+            this.computed = config.computed;
+        }
+        //添加方法属性
+        if (typeof config.methods == "undefined") {
+            this.methods = {};
+        }
+        else {
+            this.methods = config.methods;
+        }
+        //添加监控属性
+        if (typeof config.watcher == "undefined") {
+            this.watcher = {};
+        }
+        else {
+            this.watcher = config.watcher;
+        }
+        //生命周期函数
+        if (typeof config.beforeRender == "undefined") {
+            this.beforeRender = function () { };
+        }
+        else {
+            this.beforeRender = config.beforeRender;
+        }
+        if (typeof config.afterRender == "undefined") {
+            this.afterRender = function () { };
+        }
+        else {
+            this.afterRender = config.afterRender;
+        }
+        if (typeof config.beforeUpdate == "undefined") {
+            this.beforeUpdate = function () { };
+        }
+        else {
+            this.beforeUpdate = config.beforeUpdate;
+        }
+        if (typeof config.afterUpdate == "undefined") {
+            this.afterUpdate = function () { };
+        }
+        else {
+            this.afterUpdate = config.afterUpdate;
+        }
+        if (typeof config.beforeMount == "undefined") {
+            this.beforeMount = function () { };
+        }
+        else {
+            this.beforeMount = config.beforeMount;
+        }
+        if (typeof config.beforeUnmount == "undefined") {
+            this.beforeUnmount = function () { };
+        }
+        else {
+            this.beforeUnmount = config.beforeUnmount;
+        }
+    }
+    ApiComponent.prototype.getName = function () {
+        return this.name;
+    };
+    ApiComponent.prototype.getTemplate = function () {
+        return this.template;
+    };
+    ApiComponent.prototype.getData = function () {
+        return this.data;
+    };
+    ApiComponent.prototype.getMethods = function () {
+        return this.methods;
+    };
+    ApiComponent.prototype.getComputed = function () {
+        return this.computed;
+    };
+    ApiComponent.prototype.getWatcher = function () {
+        return this.watcher;
+    };
+    ApiComponent.prototype.getBeforeRender = function () {
+        return this.beforeRender;
+    };
+    ApiComponent.prototype.getAfterRender = function () {
+        return this.afterRender;
+    };
+    ApiComponent.prototype.getBeforeUpdate = function () {
+        return this.beforeUpdate;
+    };
+    ApiComponent.prototype.getAfterUpdate = function () {
+        return this.afterUpdate;
+    };
+    ApiComponent.prototype.getBeforeMount = function () {
+        return this.beforeMount;
+    };
+    ApiComponent.prototype.getBeforeUnmount = function () {
+        return this.beforeUnmount;
+    };
+    return ApiComponent;
+}());
+export default ApiComponent;

package/class/apiController.d.ts

@@ -0,0 +1,13 @@
+import ApiComponent from "./apiComponent";
+import { Controller } from "./controller";
+export declare class ApiController {
+    root: ParentNode;
+    proto: ApiComponent;
+    preRender: boolean;
+    link: Map<string, {}>;
+    to: Controller[];
+    raw_data: {};
+    proxyForMethods: {};
+    constructor();
+    receiver(method: string, ...args: any[]): any;
+}

package/class/apiController.js

@@ -0,0 +1,16 @@
+var ApiController = /** @class */ (function () {
+    function ApiController() {
+        this.link = new Map();
+        this.preRender = false;
+    }
+    //接收器
+    ApiController.prototype.receiver = function (method) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return this.proto.getMethods()[method].apply(this.proxyForMethods, args);
+    };
+    return ApiController;
+}());
+export { ApiController };

package/class/component.d.ts

@@ -0,0 +1,63 @@
+interface RenderBase {
+    getName(): string;
+    getTemplate(): string;
+    getProps(): {};
+    getData(): {};
+    getComputed(): {};
+    getMethods(): {};
+    getWatcher(): {};
+    getExecutor(): {};
+    getBeforeRender(): () => void;
+    getAfterRender(): () => void;
+    getBeforeUpdate(): () => void;
+    getAfterUpdate(): () => void;
+    getBeforeMount(): () => void;
+    getBeforeUnmount(): () => void;
+}
+export declare class Component implements RenderBase {
+    private readonly name;
+    private readonly template;
+    private readonly props?;
+    private readonly data;
+    private readonly methods?;
+    private readonly computed?;
+    private readonly watcher?;
+    private readonly executor?;
+    private readonly beforeRender?;
+    private readonly afterRender?;
+    private readonly beforeUpdate?;
+    private readonly afterUpdate?;
+    private readonly beforeMount?;
+    private readonly beforeUnmount?;
+    constructor(config: {
+        name: string;
+        template: string;
+        props?: {};
+        data?: {};
+        computed?: {};
+        methods?: {};
+        watcher?: {};
+        executor?: {};
+        beforeRender?: () => void;
+        afterRender?: () => void;
+        beforeUpdate?: () => void;
+        afterUpdate?: () => void;
+        beforeMount?: () => void;
+        beforeUnmount?: () => void;
+    });
+    getName(): string;
+    getTemplate(): string;
+    getProps(): {};
+    getData(): {};
+    getMethods(): {};
+    getComputed(): {};
+    getWatcher(): {};
+    getExecutor(): {};
+    getBeforeRender(): () => void;
+    getAfterRender(): () => void;
+    getBeforeUpdate(): () => void;
+    getAfterUpdate(): () => void;
+    getBeforeMount(): () => void;
+    getBeforeUnmount(): () => void;
+}
+export {};

package/class/component.js

@@ -0,0 +1,131 @@
+var Component = /** @class */ (function () {
+    function Component(config) {
+        //标签名称
+        this.name = config.name;
+        //标签模板样式
+        this.template = config.template;
+        //添加数据
+        if (typeof config.props == "undefined") {
+            this.props = {};
+        }
+        else {
+            this.props = config.props;
+        }
+        //添加数据
+        if (typeof config.data == "undefined") {
+            this.data = {};
+        }
+        else {
+            this.data = config.data;
+        }
+        //添加计算属性
+        if (config.computed == "undefined") {
+            this.computed = {};
+        }
+        else {
+            this.computed = config.computed;
+        }
+        //添加方法属性
+        if (typeof config.methods == "undefined") {
+            this.methods = {};
+        }
+        else {
+            this.methods = config.methods;
+        }
+        //添加监控属性
+        if (typeof config.watcher == "undefined") {
+            this.watcher = {};
+        }
+        else {
+            this.watcher = config.watcher;
+        }
+        //添加处理器属性
+        if (typeof config.executor == "undefined") {
+            this.executor = {};
+        }
+        else {
+            this.executor = config.executor;
+        }
+        //生命周期函数
+        if (typeof config.beforeRender == "undefined") {
+            this.beforeRender = function () { };
+        }
+        else {
+            this.beforeRender = config.beforeRender;
+        }
+        if (typeof config.afterRender == "undefined") {
+            this.afterRender = function () { };
+        }
+        else {
+            this.afterRender = config.afterRender;
+        }
+        if (typeof config.beforeUpdate == "undefined") {
+            this.beforeUpdate = function () { };
+        }
+        else {
+            this.beforeUpdate = config.beforeUpdate;
+        }
+        if (typeof config.afterUpdate == "undefined") {
+            this.afterUpdate = function () { };
+        }
+        else {
+            this.afterUpdate = config.afterUpdate;
+        }
+        if (typeof config.beforeMount == "undefined") {
+            this.beforeMount = function () { };
+        }
+        else {
+            this.beforeMount = config.beforeMount;
+        }
+        if (typeof config.beforeUnmount == "undefined") {
+            this.beforeUnmount = function () { };
+        }
+        else {
+            this.beforeUnmount = config.beforeUnmount;
+        }
+    }
+    Component.prototype.getName = function () {
+        return this.name;
+    };
+    Component.prototype.getTemplate = function () {
+        return this.template;
+    };
+    Component.prototype.getProps = function () {
+        return this.props;
+    };
+    Component.prototype.getData = function () {
+        return this.data;
+    };
+    Component.prototype.getMethods = function () {
+        return this.methods;
+    };
+    Component.prototype.getComputed = function () {
+        return this.computed;
+    };
+    Component.prototype.getWatcher = function () {
+        return this.watcher;
+    };
+    Component.prototype.getExecutor = function () {
+        return this.executor;
+    };
+    Component.prototype.getBeforeRender = function () {
+        return this.beforeRender;
+    };
+    Component.prototype.getAfterRender = function () {
+        return this.afterRender;
+    };
+    Component.prototype.getBeforeUpdate = function () {
+        return this.beforeUpdate;
+    };
+    Component.prototype.getAfterUpdate = function () {
+        return this.afterUpdate;
+    };
+    Component.prototype.getBeforeMount = function () {
+        return this.beforeMount;
+    };
+    Component.prototype.getBeforeUnmount = function () {
+        return this.beforeUnmount;
+    };
+    return Component;
+}());
+export { Component };

package/class/controller.d.ts

@@ -0,0 +1,12 @@
+import { Component } from "./component";
+export declare class Controller {
+    root: ParentNode;
+    proto: Component;
+    preRender: boolean;
+    link: Map<string, {}>;
+    to: Controller[];
+    raw_data: {};
+    proxyForMethods: {};
+    constructor();
+    receiver(method: string, ...args: any[]): any;
+}

package/class/controller.js

@@ -0,0 +1,18 @@
+var Controller = /** @class */ (function () {
+    //构造函数
+    function Controller() {
+        this.link = new Map();
+        this.preRender = false;
+        this.to = [];
+    }
+    //接收器
+    Controller.prototype.receiver = function (method) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return this.proto.getMethods()[method].apply(this.proxyForMethods, args);
+    };
+    return Controller;
+}());
+export { Controller };

package/core/cmd/v-bind.d.ts

@@ -0,0 +1 @@
+export declare function resolver_bind(nodes: HTMLCollection, data: {}): void;

package/core/cmd/v-bind.js

@@ -0,0 +1,25 @@
+export function resolver_bind(nodes, data) {
+    for (var i = 0; i < nodes.length; i++) {
+        var attributes = nodes[i].getAttributeNames();
+        for (var j = 0; j < attributes.length; j++) {
+            var result = attributes[j].match(/^v-bind:([a-z]+)$/g);
+            if (result === null) {
+            }
+            else {
+                for (var k = 0; k < result.length; k++) {
+                    var property = result[k].substring(7);
+                    var dataName = nodes[i].getAttribute(result[k]);
+                    nodes[i].removeAttribute(result[k]);
+                    try {
+                        nodes[i].setAttribute(property, JSON.stringify(data[dataName]));
+                    }
+                    catch (e) {
+                        nodes[i].setAttribute(property, data[dataName]);
+                    }
+                }
+            }
+        }
+        var subElements = nodes[i].children;
+        resolver_bind(subElements, data);
+    }
+}

package/core/cmd/v-html.d.ts

@@ -0,0 +1 @@
+export declare function resolver_html(elements: HTMLCollection, data: {}): void;

package/core/cmd/v-html.js

@@ -0,0 +1,13 @@
+export function resolver_html(elements, data) {
+    for (var i = 0; i < elements.length; i++) {
+        var result = elements[i].hasAttribute("v-html");
+        if (result) {
+            var dataName = elements[i].getAttribute("v-html");
+            elements[i].removeAttribute("v-html");
+            // @ts-ignore
+            elements[i].innerHTML = data[dataName];
+        }
+        var subElements = elements[i].children;
+        resolver_html(subElements, data);
+    }
+}

package/core/cmd/v-model.d.ts

@@ -0,0 +1 @@
+export declare function resolver_model(nodes: HTMLCollection, data: {}): void;

package/core/cmd/v-model.js

@@ -0,0 +1,34 @@
+export function resolver_model(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);
+            if (tagName === "INPUT" || tagName === "SELECT" || tagName === "TEXTAREA") {
+                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));
+            }
+        }
+        var kk = nodes[i].children;
+        resolver_model(kk, data);
+    }
+}

package/core/cmd/v-on.d.ts

@@ -0,0 +1 @@
+export declare function resolver_event(elements: HTMLCollection, methods: {}, data: {}): void;

package/core/cmd/v-on.js

@@ -0,0 +1,25 @@
+export function resolver_event(elements, methods, data) {
+    //遍历所有的元素节点
+    for (var i = 0; i < elements.length; i++) {
+        //获取元素节点所有属性
+        var attributes = elements[i].getAttributeNames();
+        //解析元素的所有属性
+        for (var j = 0; j < attributes.length; j++) {
+            //检查属性名称以及匹配绑定方法
+            var result = attributes[j].match(/^v-on:([a-z]+)$/g);
+            //如何属性匹配
+            if (result !== null) {
+                for (var k = 0; k < result.length; k++) {
+                    var action = result[k].substring(5);
+                    var method = elements[i].getAttribute(result[k]);
+                    elements[i].removeAttribute(result[k]);
+                    elements[i].addEventListener(action, methods[method].bind(data));
+                }
+            }
+        }
+        //获取该组件的
+        var subElements = elements[i].children;
+        //深度解析属性
+        resolver_event(subElements, methods, data);
+    }
+}

package/core/cmd/v-ref.d.ts

@@ -0,0 +1 @@
+export declare function resolver_Ref(el: HTMLCollection): Map<string, Element>;

package/core/cmd/v-ref.js

@@ -0,0 +1,10 @@
+import { getProxyForInject } from "../proxy/getProxy";
+export function resolver_Ref(el) {
+    var ref = new Map();
+    for (var i = 0; i < el.length; i++) {
+        if (el[i].hasAttribute("ref")) {
+            ref.set(el[i].getAttribute("ref"), el[i]);
+        }
+    }
+    return getProxyForInject(ref);
+}

package/core/cmd/v-render.d.ts

@@ -0,0 +1 @@
+export declare function resolver_render(elements: HTMLCollection, data: {}): void;

package/core/cmd/v-render.js

@@ -0,0 +1,21 @@
+export function resolver_render(elements, data) {
+    for (var i = 0; i < elements.length; i++) {
+        var result = elements[i].hasAttribute("v-render");
+        if (result) {
+            var dataName = elements[i].getAttribute("v-render");
+            elements[i].removeAttribute("v-render");
+            if (data[dataName] instanceof Boolean) {
+                if (data[dataName] === true) {
+                    // @ts-ignore
+                    elements[i].style.display = "block";
+                }
+                else {
+                    // @ts-ignore
+                    elements[i].style.display = "none";
+                }
+            }
+        }
+        var subElements = elements[i].children;
+        resolver_render(subElements, data);
+    }
+}

package/core/cmd/v-show.d.ts

@@ -0,0 +1 @@
+export declare function resolver_show(elements: HTMLCollection, data: {}): void;

package/core/cmd/v-show.js

@@ -0,0 +1,21 @@
+export function resolver_show(elements, data) {
+    for (var i = 0; i < elements.length; i++) {
+        var result = elements[i].hasAttribute("v-show");
+        if (result) {
+            var dataName = elements[i].getAttribute("v-show");
+            elements[i].removeAttribute("v-show");
+            if (data[dataName] instanceof Boolean) {
+                if (data[dataName] === true) {
+                    // @ts-ignore
+                    elements[i].style.visibility = true;
+                }
+                else {
+                    // @ts-ignore
+                    elements[i].style.visibility = false;
+                }
+            }
+        }
+        var subElements = elements[i].children;
+        resolver_show(subElements, data);
+    }
+}

package/core/cmd/v-txt.d.ts

@@ -0,0 +1 @@
+export declare function resolver_txt(elements: HTMLCollection, data: {}): void;

package/core/cmd/v-txt.js

@@ -0,0 +1,13 @@
+export function resolver_txt(elements, data) {
+    for (var i = 0; i < elements.length; i++) {
+        var result = elements[i].hasAttribute("v-txt");
+        if (result) {
+            var dataName = elements[i].getAttribute("v-txt");
+            elements[i].removeAttribute("v-txt");
+            // @ts-ignore
+            elements[i].innerText = data[dataName];
+        }
+        var subElements = elements[i].children;
+        resolver_txt(subElements, data);
+    }
+}

package/core/proxy/getProxy.d.ts

@@ -0,0 +1,5 @@
+import { Controller } from "../../class/controller";
+import { ApiController } from "../../class/apiController";
+export declare function getProxyObject(obj: {}, updater: Controller): any;
+export declare function getProxyObjectForApi(obj: {}, updater: ApiController): any;
+export declare function getProxyForInject(obj: {}): any;

package/core/proxy/getProxy.js

@@ -0,0 +1,19 @@
+import { getSetter, getSetterForApi, getSetterForInject } from "../../library/setter/setter";
+export function getProxyObject(obj, updater) {
+    //定义代理方法对象
+    var handel = {};
+    //获取set代理方法
+    handel["set"] = getSetter(obj, updater);
+    //返回代理对象
+    return new Proxy(obj, handel);
+}
+export function getProxyObjectForApi(obj, updater) {
+    var handel = {};
+    handel["set"] = getSetterForApi(obj, updater);
+    return new Proxy(obj, handel);
+}
+export function getProxyForInject(obj) {
+    var handel = {};
+    handel["set"] = getSetterForInject(obj);
+    return new Proxy(obj, handel);
+}

package/core/render/apiRender.d.ts

@@ -0,0 +1,4 @@
+import { Component } from "../../class/component";
+import ApiComponent from "../../class/apiComponent";
+import { ApiController } from "../../class/apiController";
+export declare function apiRender(proto: ApiComponent, parent: ParentNode, attr: string, tagLib: Map<string, Component>, link: ApiController): any;