render-core 1.4.0 → 1.4.1

package/kernel/directive/property/v-bind.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param nodes
+ * @param data
+ */
+export declare function parse_directive_bind(nodes: HTMLCollection, data: {}): void;

package/{core/cmd → kernel/directive}/property/v-bind.js

@@ -1,10 +1,10 @@
-import { isUnKnown } from "../../utility/checkUtility";
+import { isUnKnown } from "../../../system/utility/checkUtility";
 /**
  *
  * @param nodes
  * @param data
  */
-export function resolver_bind(nodes, data) {
+export function parse_directive_bind(nodes, data) {
     for (var i = 0; i < nodes.length; i++) {
         //对系统元素进行属性绑定
         if (!isUnKnown(nodes[i].nodeName)) {
@@ -27,7 +27,7 @@ export function resolver_bind(nodes, data) {
                     }
                 }
             }
-            resolver_bind(nodes[i].children, data);
+            parse_directive_bind(nodes[i].children, data);
         }
     }
 }

package/kernel/directive/react/v-model.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 绑定数据模型
+ * @param nodes
+ * @param data
+ */
+export declare function parse_directive_model(nodes: HTMLCollection, data: {}): void;

package/{core/cmd → kernel/directive}/react/v-model.js

@@ -1,10 +1,10 @@
-import { compositionend, compositionstart, listener } from "../../utility/modelUtility";
+import { compositionend, compositionstart, listener } from "../../../system/utility/modelUtility";
 /**
  * 绑定数据模型
  * @param nodes
  * @param data
  */
-export function resolver_model(nodes, data) {
+export function parse_directive_model(nodes, data) {
     for (var i = 0; i < nodes.length; i++) {
         if (nodes[i].hasAttribute("@model")) {
             var dataName = nodes[i].getAttribute("@model");
@@ -17,6 +17,6 @@ export function resolver_model(nodes, data) {
                 nodes[i].addEventListener("compositionend", compositionend.bind(data));
             }
         }
-        resolver_model(nodes[i].children, data);
+        parse_directive_model(nodes[i].children, data);
     }
 }

package/kernel/directive/ref/v-ref.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param el
+ * @param refs
+ */
+export declare function parse_directive_refs(el: HTMLCollection, refs: Map<string, Element>): void;

package/{core/cmd → kernel/directive}/ref/v-ref.js

@@ -3,14 +3,14 @@
  * @param el
  * @param refs
  */
-export function resolver_Refs(el, refs) {
+export function parse_directive_refs(el, refs) {
     for (var i = 0; i < el.length; i++) {
         if (el[i].hasAttribute("@ref")) {
             refs.set(el[i].getAttribute("@ref"), el[i]);
             el[i].removeAttribute("@ref");
         }
         else {
-            resolver_Refs(el[i].children, refs);
+            parse_directive_refs(el[i].children, refs);
         }
     }
 }

package/kernel/directive/salt/v-solt.d.ts

@@ -0,0 +1,13 @@
+import { ContextController } from "../../../system/define/ContextController";
+/**
+ * 此函数用于解析自定义元素salt
+ * @param tagTemplate
+ * @param controller
+ */
+export declare function parse_directive_salt_collect(tagTemplate: ChildNode, controller: ContextController): void;
+/**
+ * 此函数用于展开salt
+ * @param elements
+ * @param controller
+ */
+export declare function parse_directive_salt_extract(elements: HTMLCollection, controller: ContextController): void;

package/{core/cmd/solt → kernel/directive/salt}/v-solt.js

@@ -1,22 +1,22 @@
 /**
- * 此函数用于解析自定义元素solt
+ * 此函数用于解析自定义元素salt
  * @param tagTemplate
  * @param controller
  */
-export function resolver_salt(tagTemplate, controller) {
+export function parse_directive_salt_collect(tagTemplate, controller) {
     if (tagTemplate.hasChildNodes()) {
+        // @ts-ignore
         var list = tagTemplate.querySelectorAll("salt");
         if (list.length !== 0) {
             list.forEach(function (value) {
-                if (value.hasAttribute("name")) {
+                if (value.hasAttribute("name"))
                     controller.salt.set(value.getAttribute("name"), value.innerHTML);
-                }
-                else {
+                else
                     controller.salt.set("default", value.innerHTML);
-                }
             });
         }
         else {
+            // @ts-ignore
             controller.salt.set("default", tagTemplate.innerHTML);
         }
     }
@@ -26,7 +26,7 @@ export function resolver_salt(tagTemplate, controller) {
  * @param elements
  * @param controller
  */
-export function extract_salt(elements, controller) {
+export function parse_directive_salt_extract(elements, controller) {
     for (var i = 0; i < elements.length; i++) {
         var result = elements[i].hasAttribute("@salt");
         if (result) {
@@ -41,6 +41,6 @@ export function extract_salt(elements, controller) {
             }
         }
         //深度解析
-        extract_salt(elements[i].children, controller);
+        parse_directive_salt_extract(elements[i].children, controller);
     }
 }

package/kernel/proxyer/getProxy.d.ts

@@ -0,0 +1,9 @@
+import { ContextController } from "../../system/define/ContextController";
+/**
+ * 获取data对象的代理对象
+ * @param data
+ * @param updater
+ */
+export declare function get_proxy_for_method(data: {}, updater: ContextController): any;
+export declare function get_proxy_for_watcher(origin: object): object;
+export declare function get_proxy_for_computed(origin: object): object;

package/kernel/proxyer/getProxy.js

@@ -0,0 +1,35 @@
+import { update_Render } from "../renderer/updateRender";
+import { locateInputAddress } from "../../system/utility/sectionUtility";
+/**
+ * 获取data对象的代理对象
+ * @param data
+ * @param updater
+ */
+export function get_proxy_for_method(data, updater) {
+    var handel = {};
+    handel["set"] = get_setter_for_method_proxy(updater);
+    return new Proxy(data, handel);
+}
+function get_setter_for_method_proxy(updater) {
+    var setter = function (obj, prop, value) {
+        try {
+            this.watcher[prop](obj[prop], value);
+        }
+        catch (error) {
+        }
+        Reflect.set(obj, prop, value);
+        update_Render(this);
+        locateInputAddress(this);
+        Reflect.deleteProperty(this, "origin");
+        return true;
+    };
+    return setter.bind(updater);
+}
+export function get_proxy_for_watcher(origin) {
+    var handles = {};
+    return new Proxy(origin, handles);
+}
+export function get_proxy_for_computed(origin) {
+    var handles = {};
+    return new Proxy(origin, handles);
+}

package/kernel/renderer/initRender.d.ts

@@ -0,0 +1,10 @@
+import { ContextController } from "../../system/define/ContextController";
+import { Component } from "../../index";
+/**
+ * 该函数用于处理需要更更新时候，需要从父组件提取数据状态的渲染操作
+ * @param protoType
+ * @param parent
+ * @param child
+ * @param parentController
+ */
+export declare function init_renderer(protoType: Component, parent: ParentNode, child: ChildNode, parentController: ContextController): void;

package/kernel/renderer/initRender.js

@@ -0,0 +1,69 @@
+import { ContextController } from "../../system/define/ContextController";
+import { directive_parse_collection_for_after, directive_parse_collection_for_before } from "../../system/utility/cmdUtility";
+import { archive_mount, extract_mount } from "../../system/lifecycle/mount";
+import { inject_$name_to_data, inject_$plugin_to_config, inject_$props_to_data, inject_$refs_to_data, inject_computed_to_controller, inject_method_to_data, inject_watcher_to_controller, } from "../../system/injection/inject";
+import { after_process_for_init } from "../../system/lifecycle/lifeCycle";
+import { findComponent } from "../delivery/delivery";
+import { getTemplate } from "../../system/utility/templateUtility";
+import { loader_tag_style } from "../../system/utility/styleUtility";
+import { get_plugin_library, get_style_library } from "../../system/recorder/table0/system_func_0";
+import { get_proxy_for_computed, get_proxy_for_method, get_proxy_for_watcher } from "../proxyer/getProxy";
+import { getCodeSpaceForCommit, getCodeSpaceForPublish, getGetCodeSpaceForProperty, getSetCodeSpaceForProperty } from "../../system/utility/injectUtility";
+import { getCommitMethod, getGetterMethod, getPublishMethod, getSetterMethod } from "../../system/injection/injection";
+import { parse_directive_salt_collect } from "../directive/salt/v-solt";
+/**
+ * 该函数用于处理需要更更新时候，需要从父组件提取数据状态的渲染操作
+ * @param protoType
+ * @param parent
+ * @param child
+ * @param parentController
+ */
+export function init_renderer(protoType, parent, child, parentController) {
+    /* initiate the rang vars */
+    var tagTemplate = getTemplate(protoType);
+    var currentController = new ContextController({ boxMode: true });
+    /* some resolvers */
+    parse_directive_salt_collect(child, currentController);
+    /* some loaders */
+    loader_tag_style(protoType.getName(), get_style_library());
+    /* some injections to config class */
+    Reflect.set(currentController.componentConfig, "$plugins", get_plugin_library());
+    /* initiate to controller */
+    currentController.parentController = parentController;
+    currentController.prototypeOfComponent = protoType;
+    currentController.componentConfig.boxMode = protoType.getConfig()["boxMode"];
+    // @ts-ignore
+    currentController.originalData = parentController.lazyComponent.get(child.getAttribute("name"));
+    currentController.dataForMethod = get_proxy_for_method(currentController.originalData, currentController);
+    currentController.dataForComputed = get_proxy_for_computed(currentController.originalData);
+    currentController.dataForWatcher = get_proxy_for_watcher(currentController.originalData);
+    /* inject to original data source */
+    inject_$name_to_data(protoType.getName(), currentController.originalData);
+    inject_$props_to_data(child, protoType.getProps(), currentController.originalData);
+    inject_$refs_to_data(tagTemplate, currentController.originalData);
+    inject_$plugin_to_config(currentController.componentConfig);
+    /* initiate method, computed, watcher */
+    inject_method_to_data(currentController, protoType);
+    inject_computed_to_controller(currentController, protoType);
+    inject_watcher_to_controller(currentController, protoType);
+    //注入commit
+    getCodeSpaceForCommit(currentController.originalData, getCommitMethod(parentController));
+    getCodeSpaceForPublish(currentController.originalData, getPublishMethod(currentController));
+    getSetCodeSpaceForProperty(currentController.originalData, getSetterMethod(currentController));
+    getGetCodeSpaceForProperty(currentController.originalData, getGetterMethod(currentController));
+    protoType.getBeforeRender().apply(currentController.originalData, null);
+    /* directive parse before */
+    directive_parse_collection_for_before(tagTemplate, protoType, currentController);
+    /* archive mount */
+    archive_mount(currentController, protoType, parent, child, tagTemplate);
+    /* directive parse after */
+    directive_parse_collection_for_after(currentController.componentAttachedRootElement, currentController);
+    protoType.getAfterRender().apply(currentController.dataForMethod, null);
+    /* after process for render */
+    after_process_for_init(currentController, child, parentController);
+    /* find the next element to render */
+    findComponent(currentController.componentAttachedRootElement.children, currentController);
+    if (!protoType.getConfig()["boxMode"])
+        /* extract mount */
+        extract_mount(currentController);
+}

package/kernel/renderer/postRender.d.ts

@@ -0,0 +1,10 @@
+import { ContextController } from "../../system/define/ContextController";
+import { Component } from "../../index";
+/**
+ * 该函数用于处理需要更更新时候，需要从父组件提取数据状态的渲染操作
+ * @param protoType
+ * @param parent
+ * @param child
+ * @param parentController
+ */
+export declare function post_renderer(protoType: Component, parent: ParentNode, child: ChildNode, parentController: ContextController): void;

package/kernel/renderer/postRender.js

@@ -0,0 +1,70 @@
+import { ContextController } from "../../system/define/ContextController";
+import { directive_parse_collection_for_after, directive_parse_collection_for_before } from "../../system/utility/cmdUtility";
+import { archive_mount, extract_mount } from "../../system/lifecycle/mount";
+import { inject_$name_to_data, inject_$plugin_to_config, inject_$props_to_data, inject_$refs_to_data, inject_computed_to_controller, inject_method_to_data, inject_watcher_to_controller, } from "../../system/injection/inject";
+import { after_process_for_post } from "../../system/lifecycle/lifeCycle";
+import { findComponent } from "../delivery/delivery";
+import { parse_directive_salt_collect } from "../directive/salt/v-solt";
+import { getTemplate } from "../../system/utility/templateUtility";
+import { loader_tag_style } from "../../system/utility/styleUtility";
+import { get_plugin_library, get_style_library } from "../../system/recorder/table0/system_func_0";
+import { get_proxy_for_computed, get_proxy_for_method, get_proxy_for_watcher } from "../proxyer/getProxy";
+import { dataInject } from "../../system/utility/dataUtility";
+import { getCodeSpaceForCommit, getCodeSpaceForPublish, getGetCodeSpaceForProperty, getSetCodeSpaceForProperty } from "../../system/utility/injectUtility";
+import { getCommitMethod, getGetterMethod, getPublishMethod, getSetterMethod } from "../../system/injection/injection";
+/**
+ * 该函数用于处理需要更更新时候，需要从父组件提取数据状态的渲染操作
+ * @param protoType
+ * @param parent
+ * @param child
+ * @param parentController
+ */
+export function post_renderer(protoType, parent, child, parentController) {
+    /* initiate the rang vars */
+    var tagTemplate = getTemplate(protoType);
+    var currentController = new ContextController({ boxMode: true });
+    /* some resolvers */
+    parse_directive_salt_collect(child, currentController);
+    /* some loaders */
+    loader_tag_style(protoType.getName(), get_style_library());
+    /* some injections to config class */
+    Reflect.set(currentController.componentConfig, "$plugins", get_plugin_library());
+    /* initiate to controller */
+    currentController.parentController = parentController;
+    currentController.prototypeOfComponent = protoType;
+    currentController.componentConfig.boxMode = protoType.getConfig()["boxMode"];
+    // @ts-ignore
+    currentController.originalData = dataInject(protoType.getData());
+    currentController.dataForMethod = get_proxy_for_method(currentController.originalData, currentController);
+    currentController.dataForComputed = get_proxy_for_computed(currentController.originalData);
+    currentController.dataForWatcher = get_proxy_for_watcher(currentController.originalData);
+    /* inject to original data source */
+    inject_$name_to_data(protoType.getName(), currentController.originalData);
+    inject_$props_to_data(child, protoType.getProps(), currentController.originalData);
+    inject_$refs_to_data(tagTemplate, currentController.originalData);
+    inject_$plugin_to_config(currentController.componentConfig);
+    //注入commit
+    getCodeSpaceForCommit(currentController.originalData, getCommitMethod(parentController));
+    getCodeSpaceForPublish(currentController.originalData, getPublishMethod(currentController));
+    getSetCodeSpaceForProperty(currentController.originalData, getSetterMethod(currentController));
+    getGetCodeSpaceForProperty(currentController.originalData, getGetterMethod(currentController));
+    /* initiate method, computed, watcher */
+    inject_method_to_data(currentController, protoType);
+    inject_computed_to_controller(currentController, protoType);
+    inject_watcher_to_controller(currentController, protoType);
+    protoType.getBeforeRender().apply(currentController.originalData, null);
+    /* directive parse before */
+    directive_parse_collection_for_before(tagTemplate, protoType, currentController);
+    /* archive mount */
+    archive_mount(currentController, protoType, parent, child, tagTemplate);
+    /* directive parse after */
+    directive_parse_collection_for_after(currentController.componentAttachedRootElement, currentController);
+    protoType.getAfterRender().apply(currentController.dataForMethod, null);
+    /* after process for render */
+    after_process_for_post(currentController, parentController);
+    /* find the next element to render */
+    findComponent(currentController.componentAttachedRootElement.children, currentController);
+    if (!protoType.getConfig()["boxMode"])
+        /* extract mount */
+        extract_mount(currentController);
+}

package/kernel/renderer/rawRender.d.ts

@@ -0,0 +1,10 @@
+import { ContextController } from "../../system/define/ContextController";
+import { Component } from "../../index";
+/**
+ * 该函数用于处理需要更更新时候，需要从父组件提取数据状态的渲染操作
+ * @param protoType
+ * @param parent
+ * @param child
+ * @param parentController
+ */
+export declare function raw_renderer(protoType: Component, parent: ParentNode, child: ChildNode, parentController: ContextController): void;

package/kernel/renderer/rawRender.js

@@ -0,0 +1,70 @@
+import { ContextController } from "../../system/define/ContextController";
+import { directive_parse_collection_for_after, directive_parse_collection_for_before } from "../../system/utility/cmdUtility";
+import { archive_mount, extract_mount } from "../../system/lifecycle/mount";
+import { inject_$name_to_data, inject_$plugin_to_config, inject_$props_to_data, inject_$refs_to_data, inject_computed_to_controller, inject_method_to_data, inject_watcher_to_controller, } from "../../system/injection/inject";
+import { after_process_for_post } from "../../system/lifecycle/lifeCycle";
+import { findComponent } from "../delivery/delivery";
+import { parse_directive_salt_collect } from "../directive/salt/v-solt";
+import { getTemplate } from "../../system/utility/templateUtility";
+import { loader_tag_style } from "../../system/utility/styleUtility";
+import { get_plugin_library, get_style_library } from "../../system/recorder/table0/system_func_0";
+import { get_proxy_for_computed, get_proxy_for_method, get_proxy_for_watcher } from "../proxyer/getProxy";
+import { dataInject } from "../../system/utility/dataUtility";
+import { getCodeSpaceForCommit, getCodeSpaceForPublish, getGetCodeSpaceForProperty, getSetCodeSpaceForProperty } from "../../system/utility/injectUtility";
+import { getCommitMethod, getGetterMethod, getPublishMethod, getSetterMethod } from "../../system/injection/injection";
+/**
+ * 该函数用于处理需要更更新时候，需要从父组件提取数据状态的渲染操作
+ * @param protoType
+ * @param parent
+ * @param child
+ * @param parentController
+ */
+export function raw_renderer(protoType, parent, child, parentController) {
+    /* initiate the rang vars */
+    var tagTemplate = getTemplate(protoType);
+    var currentController = new ContextController({ boxMode: true });
+    /* some resolvers */
+    parse_directive_salt_collect(child, currentController);
+    /* some loaders */
+    loader_tag_style(protoType.getName(), get_style_library());
+    /* some injections to config class */
+    Reflect.set(currentController.componentConfig, "$plugins", get_plugin_library());
+    /* initiate to controller */
+    currentController.parentController = parentController;
+    currentController.prototypeOfComponent = protoType;
+    currentController.componentConfig.boxMode = protoType.getConfig()["boxMode"];
+    // @ts-ignore
+    currentController.originalData = dataInject(protoType.getData());
+    currentController.dataForMethod = get_proxy_for_method(currentController.originalData, currentController);
+    currentController.dataForComputed = get_proxy_for_computed(currentController.originalData);
+    currentController.dataForWatcher = get_proxy_for_watcher(currentController.originalData);
+    /* inject to original data source */
+    inject_$name_to_data(protoType.getName(), currentController.originalData);
+    inject_$props_to_data(child, protoType.getProps(), currentController.originalData);
+    inject_$refs_to_data(tagTemplate, currentController.originalData);
+    inject_$plugin_to_config(currentController.componentConfig);
+    //注入commit
+    getCodeSpaceForCommit(currentController.originalData, getCommitMethod(parentController));
+    getCodeSpaceForPublish(currentController.originalData, getPublishMethod(currentController));
+    getSetCodeSpaceForProperty(currentController.originalData, getSetterMethod(currentController));
+    getGetCodeSpaceForProperty(currentController.originalData, getGetterMethod(currentController));
+    /* initiate method, computed, watcher */
+    inject_method_to_data(currentController, protoType);
+    inject_computed_to_controller(currentController, protoType);
+    inject_watcher_to_controller(currentController, protoType);
+    protoType.getBeforeRender().apply(currentController.originalData, null);
+    /* directive parse before */
+    directive_parse_collection_for_before(tagTemplate, protoType, currentController);
+    /* archive mount */
+    archive_mount(currentController, protoType, parent, child, tagTemplate);
+    /* directive parse after */
+    directive_parse_collection_for_after(currentController.componentAttachedRootElement, currentController);
+    protoType.getAfterRender().apply(currentController.dataForMethod, null);
+    /* after process for render */
+    after_process_for_post(currentController, parentController);
+    /* find the next element to render */
+    findComponent(currentController.componentAttachedRootElement.children, currentController);
+    if (!protoType.getConfig()["boxMode"])
+        /* extract mount */
+        extract_mount(currentController);
+}

package/kernel/renderer/updateRender.d.ts

@@ -0,0 +1,6 @@
+import { ContextController } from "../../system/define/ContextController";
+/**
+ * 更新渲染方法
+ * @param currentController
+ */
+export declare function update_Render(currentController: ContextController): void;

package/kernel/renderer/updateRender.js

@@ -0,0 +1,33 @@
+import { directive_parse_collection_for_after, directive_parse_collection_for_before, } from "../../system/utility/cmdUtility";
+import { inject_$refs_to_data } from "../../system/injection/inject";
+import { findComponent } from "../delivery/delivery";
+import { getTemplate } from "../../system/utility/templateUtility";
+import { mountForUpdate } from "../../system/lifecycle/mount";
+/**
+ * 更新渲染方法
+ * @param currentController
+ */
+export function update_Render(currentController) {
+    var tagTemplate = getTemplate(currentController.prototypeOfComponent);
+    currentController.slaveComponent = Array();
+    inject_$refs_to_data(tagTemplate, currentController.originalData);
+    //解析指令
+    directive_parse_collection_for_before(tagTemplate, currentController.prototypeOfComponent, currentController);
+    //mount
+    if (!currentController.componentConfig.boxMode) {
+        var renderSpace = mountForUpdate(tagTemplate);
+        while (currentController.begin.nextSibling !== currentController.anchor) {
+            currentController.componentAttachedRootElement.removeChild(currentController.begin.nextSibling);
+        }
+        while (renderSpace.hasChildNodes()) {
+            currentController.componentAttachedRootElement.insertBefore(renderSpace.firstChild, currentController.anchor);
+        }
+        while (renderSpace.hasChildNodes()) {
+            currentController.componentAttachedRootElement.insertBefore(renderSpace.firstChild, currentController.anchor);
+        }
+    }
+    //渲染后处理
+    directive_parse_collection_for_after(currentController.componentAttachedRootElement, currentController);
+    //深度渲染
+    findComponent(currentController.componentAttachedRootElement.children, currentController);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "render-core",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "The extendable javascript web framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -16,9 +16,6 @@
     "email": "mutian_xiangcai@outlook.com"
   },
   "license": "MIT",
-  "dependencies": {
-    "render-refer": "1.4.0"
-  },
   "devDependencies": {
     "typescript": "^5.8.3"
   }

package/{controller → system/define}/ContextController.d.ts

@@ -1,28 +1,29 @@
-import { ComponentController } from "./ComponentController";
 import { ControllerGeneric } from "../generic/ControllerGeneric";
-import { Component } from "../../render-refer/dist";
+import { Component } from "../../index";
 export declare class ContextController implements ControllerGeneric {
     componentAttachedRootElement: ParentNode | Element;
     prototypeOfComponent: Component;
-    parentController: ComponentController | ContextController;
+    parentController: ContextController;
     anchor: HTMLElement;
     begin: HTMLElement;
     componentConfig: {
         boxMode: boolean;
-        $plugins?: Map<string, any>;
+        plugins?: Map<string, any>;
     };
     originalData: {};
     dataForMethod: {};
     dataForComputed: {};
+    dataForWatcher: {};
     salt: Map<string, any>;
     lazyComponent: Map<string, {}>;
-    slaveComponent: ComponentController[];
+    slaveComponent: ContextController[];
     method: {};
-    watcher: {};
     computed: {};
+    watcher: {};
     constructor(config: {
         boxMode: boolean;
+        $plugins?: Map<string, any>;
     });
-    receiver(method: string, ...args: any[]): void;
+    receiver(method: string, ...args: any[]): any;
     flush(): void;
 }

package/system/define/ContextController.js

@@ -0,0 +1,23 @@
+import { update_Render } from "../../kernel/renderer/updateRender";
+var ContextController = /** @class */ (function () {
+    //构造函数
+    function ContextController(config) {
+        this.lazyComponent = new Map();
+        this.slaveComponent = Array();
+        this.salt = new Map();
+        this.componentConfig = config;
+    }
+    //接收器
+    ContextController.prototype.receiver = function (method) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return this.prototypeOfComponent.getMethods()[method].apply(this.dataForMethod, args);
+    };
+    ContextController.prototype.flush = function () {
+        update_Render(this);
+    };
+    return ContextController;
+}());
+export { ContextController };

package/{generic → system/generic}/ControllerGeneric.d.ts

@@ -1,10 +1,9 @@
-import { ComponentController } from "../controller/ComponentController";
-import { Component } from "../../render-refer/dist";
-import { ContextController } from "../controller/ContextController";
+import { ContextController } from "../define/ContextController";
+import { Component } from "../../index";
 export interface ControllerGeneric {
     componentAttachedRootElement: ParentNode;
     prototypeOfComponent: Component;
-    parentController: ContextController | ComponentController;
+    parentController: ContextController;
     componentConfig: {
         boxMode: boolean;
     };
@@ -13,7 +12,7 @@ export interface ControllerGeneric {
     dataForComputed: {};
     salt: Map<string, any>;
     lazyComponent: Map<string, {}>;
-    slaveComponent: ComponentController[];
+    slaveComponent: ContextController[];
     method: {};
     computed: {};
     watcher: {};

package/system/generic/RenderGeneric.d.ts

@@ -0,0 +1,4 @@
+import { AbstractPlugin } from "../../index";
+export interface RenderGeneric {
+    use_plugin(plugin: AbstractPlugin): void;
+}

package/system/injection/inject.d.ts

@@ -0,0 +1,24 @@
+import { ContextController } from "../define/ContextController";
+import { Component } from "../../index";
+export declare function inject_$name_to_data(name: string, origin: {}): void;
+export declare function inject_$props_to_data(childNode: ChildNode, meta: {} | [], origin: object): void;
+export declare function inject_$refs_to_data(template: Element, origin: object): void;
+export declare function inject_$plugin_to_config(config: object): void;
+/**
+ *
+ * @param controller
+ * @param proto
+ */
+export declare function inject_method_to_data(controller: ContextController, proto: Component): void;
+/**
+ *
+ * @param controller
+ * @param proto
+ */
+export declare function inject_watcher_to_controller(controller: ContextController, proto: Component): void;
+/**
+ *
+ * @param controller
+ * @param proto
+ */
+export declare function inject_computed_to_controller(controller: ContextController, proto: Component): void;