render-core 1.4.8 → 1.4.10

package/system/injection/injector.js

@@ -0,0 +1,77 @@
+import { resolve_props } from "../resolver/props";
+import { parse_directive_refs } from "../../kernel/directive/ref/v-ref";
+import { get_user_anonymous_ext, get_user_ext_http } from "../recorder/table3/system_func_3";
+import { get_path_variable } from "../recorder/table1/system_func_1";
+export function inject_$name_to_data(name, origin) {
+    Reflect.set(origin, "$name", name);
+}
+export function inject_$props_to_data(childNode, meta, origin) {
+    var props = resolve_props(childNode, meta);
+    Reflect.set(origin, "$props", props);
+}
+export function inject_$refs_to_data(template, origin) {
+    var refs = new Map();
+    parse_directive_refs(template.children, refs);
+    Reflect.set(origin, "$refs", refs);
+}
+export function inject_$http_to_data(origin) {
+    Reflect.set(origin, "$http", get_user_ext_http());
+}
+export function inject_$pathVariable_to_data(origin) {
+    Reflect.set(origin, "$pathVariable", get_path_variable());
+}
+export function inject_$plugin_to_data(config) {
+    Reflect.set(config, "$plugins", function (name) {
+        return get_user_anonymous_ext(name);
+    });
+}
+//注入对象
+export function inject_$commit_to_data(data, commit) {
+    Reflect.set(data, "$commit", commit);
+}
+//注入对象
+export function inject_$publish_to_data(data, publisher) {
+    Reflect.set(data, "$publish", publisher);
+}
+export function inject_$setter_to_data(data, setter) {
+    Reflect.set(data, "$set", setter);
+}
+export function inject_$getter_to_data(data, getter) {
+    Reflect.set(data, "$get", getter);
+}
+/**
+ *
+ * @param controller
+ * @param proto
+ */
+export function inject_method_to_data(controller, proto) {
+    var methods = Object.getOwnPropertyNames(proto.getMethods());
+    methods.forEach(function (value) {
+        if (value.match(/^\$\$[a-zA-Z0-9_]*/) !== null)
+            Reflect.set(controller.originalData, value, proto.getMethods()[value].bind(controller.originalData));
+        else
+            Reflect.set(controller.originalData, value, proto.getMethods()[value].bind(controller.dataForMethod));
+    });
+}
+/**
+ *
+ * @param controller
+ * @param proto
+ */
+export function inject_watcher_to_controller(controller, proto) {
+    var methods = Object.getOwnPropertyNames(proto.getWatcher());
+    methods.forEach(function (value) {
+        Reflect.set(controller.watcher, value, proto.getWatcher()[value].bind(controller.originalData));
+    });
+}
+/**
+ *
+ * @param controller
+ * @param proto
+ */
+export function inject_computed_to_controller(controller, proto) {
+    var methods = Object.getOwnPropertyNames(proto.getComputed());
+    methods.forEach(function (value) {
+        Reflect.set(controller.computed, value, proto.getComputed()[value].bind(controller.originalData));
+    });
+}

package/system/lifecycle/mount.js

@@ -15,9 +15,8 @@ export function archive_mount(controller, proto, parent, child, tagTemplate) {
     controller.componentAttachedRootElement = renderSpace;
     //开始渲染
     parent.replaceChild(renderSpace, child);
-    while (tagTemplate.hasChildNodes()) {
+    while (tagTemplate.hasChildNodes())
         renderSpace.append(tagTemplate.firstChild);
-    }
 }
 /**
  * Insert elements without div element
@@ -28,16 +27,14 @@ export function extract_mount(root) {
     begin.setAttribute("anchor", "begin");
     begin.setAttribute("style", "display:none");
     root.componentAttachedRootElement.parentNode.insertBefore(begin, root.componentAttachedRootElement);
-    root.begin = begin;
-    while (root.componentAttachedRootElement.hasChildNodes()) {
-        //插入元素到根之前
+    root.anchorBegin = begin;
+    while (root.componentAttachedRootElement.hasChildNodes())
         root.componentAttachedRootElement.parentNode.insertBefore(root.componentAttachedRootElement.firstChild, root.componentAttachedRootElement);
-    }
     var parent = root.componentAttachedRootElement.parentNode;
     // @ts-ignore
     root.anchor = root.componentAttachedRootElement;
-    root.anchor.setAttribute("anchor", "end");
-    root.anchor.setAttribute("style", "display:none");
+    root.anchorEnd.setAttribute("anchor", "end");
+    root.anchorBegin.setAttribute("style", "display:none");
     root.componentAttachedRootElement = parent;
 }
 export function mountForUpdate(tagTemplate) {

package/system/loader/loader.js

@@ -1,4 +1,4 @@
-import { checkStyleLabel } from "../utility/styleUtility";
+import { checkStyleLabel } from "../utility/style/styleUtility";
 /**
  * 加载自定义标签样式
  * @param tag

package/system/output/errorUtility.d.ts

@@ -0,0 +1,3 @@
+export declare function errorDisplay(error: Error): void;
+export declare function warnDisplay(error: Error): void;
+export declare function infoDisplay(error: Error): void;

package/system/output/errorUtility.js

@@ -0,0 +1,9 @@
+export function errorDisplay(error) {
+    console.log();
+}
+export function warnDisplay(error) {
+    console.warn();
+}
+export function infoDisplay(error) {
+    console.info();
+}

package/system/prototype/ContextController.d.ts

@@ -1,19 +1,22 @@
 import { ControllerGeneric } from "../generic/controller/ControllerGeneric";
 import { Component } from "../../index";
+import { OriginalDataGeneric } from "../generic/data/OriginalDataGeneric";
+import { ComputedDataGeneric } from "../generic/data/ComputedDataGeneric";
+import { WatcherDataGeneric } from "../generic/data/WatcherDataGeneric";
 export declare class ContextController implements ControllerGeneric {
     componentAttachedRootElement: ParentNode | Element;
     prototypeOfComponent: Component;
     parentController: ContextController;
-    anchor: HTMLElement;
-    begin: HTMLElement;
+    anchorBegin: HTMLElement;
+    anchorEnd: HTMLElement;
     componentConfig: {
         boxMode: boolean;
         plugins?: Map<string, any>;
     };
-    originalData: {};
-    dataForMethod: {};
-    dataForComputed: {};
-    dataForWatcher: {};
+    originalData: OriginalDataGeneric;
+    dataForMethod: OriginalDataGeneric;
+    dataForComputed: ComputedDataGeneric;
+    dataForWatcher: WatcherDataGeneric;
     salt: Map<string, any>;
     lazyComponent: Map<string, {}>;
     slaveComponent: ContextController[];
@@ -22,8 +25,6 @@ export declare class ContextController implements ControllerGeneric {
     watcher: {};
     constructor(config: {
         boxMode: boolean;
-        $plugins?: Map<string, any>;
     });
     receiver(method: string, ...args: any[]): any;
-    flush(): void;
 }

package/system/prototype/ContextController.js

@@ -1,13 +1,10 @@
-import { update_Render } from "../../kernel/renderer/updateRender";
 var ContextController = /** @class */ (function () {
-    //构造函数
     function ContextController(config) {
+        this.componentConfig = 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++) {
@@ -15,9 +12,6 @@ var ContextController = /** @class */ (function () {
         }
         return this.prototypeOfComponent.getMethods()[method].apply(this.dataForMethod, args);
     };
-    ContextController.prototype.flush = function () {
-        update_Render(this);
-    };
     return ContextController;
 }());
 export { ContextController };

package/system/recorder/table2/system_func_2.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This func used the check the tag
+ * @param element
+ */
+export declare function tag_unknown_check(element: string): boolean;

package/system/recorder/table2/system_func_2.js

@@ -0,0 +1,8 @@
+import system_t_2 from "./system_t_2";
+/**
+ * This func used the check the tag
+ * @param element
+ */
+export function tag_unknown_check(element) {
+    return !system_t_2.some(function (ele) { return ele == element; });
+}

package/system/utility/data/dataUtility.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This func used to generate a new original data form prototype
+ * @param data
+ */
+export declare function dataInject(data: {}): any;

package/system/utility/data/dataUtility.js

@@ -0,0 +1,12 @@
+/**
+ * This func used to generate a new original data form prototype
+ * @param data
+ */
+export function dataInject(data) {
+    var out = {};
+    var keys = Object.getOwnPropertyNames(data);
+    keys.forEach(function (value) {
+        out[value] = data[value];
+    });
+    return out;
+}

package/system/utility/directive/cmdUtility.d.ts

@@ -0,0 +1,15 @@
+import { ContextController } from "../../prototype/ContextController";
+import { Component } from "../../../index";
+/**
+ * This function is used to parse_directive those commands which should be executed before mount.
+ * @param tagTemplate
+ * @param proto
+ * @param controller
+ */
+export declare function directive_parse_collection_for_before(tagTemplate: Element, proto: Component, controller: ContextController): void;
+/**
+ * This function is used to parse_directive those commands which should be executed after mount.
+ * @param templateSpace
+ * @param controller
+ */
+export declare function directive_parse_collection_for_after(templateSpace: ParentNode, controller: ContextController): void;

package/system/utility/directive/cmdUtility.js

@@ -0,0 +1,43 @@
+import { add_label_to_element } from "../initiate/miscUtility";
+import { parse_directive_event } from "../../../kernel/directive/method/v-on";
+import { parse_directive_html } from "../../../kernel/directive/data/v-html";
+import { parse_directive_txt } from "../../../kernel/directive/data/v-txt";
+import { parse_directive_model } from "../../../kernel/directive/react/v-model";
+import { parse_directive_bind } from "../../../kernel/directive/property/v-bind";
+import { parse_directive_show } from "../../../kernel/directive/justify/v-show";
+import { parse_directive_render } from "../../../kernel/directive/justify/v-render";
+import { parse_directive_if } from "../../../kernel/directive/justify/v-if";
+import { parse_directive_switch } from "../../../kernel/directive/justify/v-switch";
+import { parse_directive_for_of } from "../../../kernel/directive/loop/v-for";
+import { parse_directive_salt_extract } from "../../../kernel/directive/salt/v-solt";
+import { parse_directive_expression } from "../../../kernel/directive/data/v-el";
+import { parse_directive_for_map } from "../../../kernel/directive/loop/v-map";
+/**
+ * This function is used to parse_directive those commands which should be executed before mount.
+ * @param tagTemplate
+ * @param proto
+ * @param controller
+ */
+export function directive_parse_collection_for_before(tagTemplate, proto, controller) {
+    add_label_to_element(tagTemplate.children, proto.getName());
+    parse_directive_event(tagTemplate.children, proto.getMethods(), controller.dataForMethod, controller.originalData);
+    parse_directive_html(tagTemplate.children, controller.dataForMethod, controller);
+    parse_directive_txt(tagTemplate.children, controller.dataForMethod, controller);
+    parse_directive_model(tagTemplate.children, controller.dataForMethod);
+    parse_directive_bind(tagTemplate.children, controller.dataForMethod);
+    parse_directive_salt_extract(tagTemplate.children, controller);
+}
+/**
+ * This function is used to parse_directive those commands which should be executed after mount.
+ * @param templateSpace
+ * @param controller
+ */
+export function directive_parse_collection_for_after(templateSpace, controller) {
+    parse_directive_show(templateSpace.children, controller.dataForMethod);
+    parse_directive_render(templateSpace.children, controller.dataForMethod);
+    parse_directive_if(templateSpace.children, controller.dataForMethod);
+    parse_directive_switch(templateSpace.children, controller.dataForMethod);
+    parse_directive_for_map(templateSpace.children, controller.dataForMethod);
+    parse_directive_for_of(templateSpace.children, controller.dataForMethod);
+    parse_directive_expression(controller.componentAttachedRootElement, controller.dataForMethod, controller);
+}

package/system/utility/initiate/miscUtility.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This func used to add tag label to the content of the user tag
+ * @param nodes
+ * @param component
+ */
+export declare function add_label_to_element(nodes: HTMLCollection, component: string): void;

package/system/utility/initiate/miscUtility.js

@@ -0,0 +1,12 @@
+/**
+ * This func used to add tag label to the content of the user tag
+ * @param nodes
+ * @param component
+ */
+export function add_label_to_element(nodes, component) {
+    for (var i = 0; i < nodes.length; i++) {
+        nodes[i].setAttribute("cpn", component);
+        var kk = nodes[i].children;
+        add_label_to_element(kk, component);
+    }
+}

package/system/utility/initiate/templateUtility.d.ts

@@ -0,0 +1,6 @@
+import { Component } from "../../../index";
+/**
+ * This func used to get the view tag from the template
+ * @param proto
+ */
+export declare function getTemplate(proto: Component): Element;

package/system/utility/initiate/templateUtility.js

@@ -0,0 +1,11 @@
+/**
+ * This func used to get the view tag from the template
+ * @param proto
+ */
+export function getTemplate(proto) {
+    var temp = document.createElement("div");
+    temp.innerHTML = proto.getTemplate();
+    var template = temp.getElementsByTagName("template")[0];
+    var content = template.content;
+    return content.querySelector("view");
+}

package/system/utility/react/inputType.d.ts

@@ -0,0 +1,25 @@
+import { ContextController } from "../../prototype/ContextController";
+/**
+ * This func used to resolve input-data which is the text type
+ * @param target
+ * @param doc
+ * @param controller
+ */
+export declare function textType(target: any, doc: any, controller: ContextController): void;
+/**
+ * This func used to resolve input-data which is the assign type
+ * @param target
+ * @param controller
+ */
+export declare function assignType(target: any, controller: ContextController): void;
+/**
+ * This func used to resolve input-data which is the file type
+ * @param target
+ * @param controller
+ */
+export declare function fileType(target: any, controller: ContextController): void;
+/**
+ * This func used to resolve input-data which is the check type
+ * @param target
+ */
+export declare function checkType(target: any): void;

package/system/utility/react/inputType.js

@@ -0,0 +1,40 @@
+/**
+ * This func used to resolve input-data which is the text type
+ * @param target
+ * @param doc
+ * @param controller
+ */
+export function textType(target, doc, controller) {
+    // @ts-ignore
+    target.value = controller.dataForMethod[target.getAttribute("name")];
+    // @ts-ignore
+    target.focus();
+    // @ts-ignore
+    target.setSelectionRange(doc.start, doc.start);
+}
+/**
+ * This func used to resolve input-data which is the assign type
+ * @param target
+ * @param controller
+ */
+export function assignType(target, controller) {
+    // @ts-ignore
+    target.value = controller.dataForMethod[target.getAttribute("name")];
+}
+/**
+ * This func used to resolve input-data which is the file type
+ * @param target
+ * @param controller
+ */
+export function fileType(target, controller) {
+    // @ts-ignore
+    target.files = controller.dataForMethod[target.getAttribute("name")];
+}
+/**
+ * This func used to resolve input-data which is the check type
+ * @param target
+ */
+export function checkType(target) {
+    // @ts-ignore
+    target.checked = "checked";
+}

package/system/utility/react/inputUtility.d.ts

@@ -0,0 +1,19 @@
+export declare function inputUtility(element: Element, space: Object): void;
+/**
+ *
+ * @param element
+ * @param space
+ */
+export declare function filesType(element: Element, space: Object): void;
+/**
+ *
+ * @param element
+ * @param space
+ */
+export declare function selectUtility(element: Element, space: Object): void;
+/**
+ *
+ * @param element
+ * @param space
+ */
+export declare function textareaUtility(element: Element, space: Object): void;

package/system/utility/react/inputUtility.js

@@ -0,0 +1,125 @@
+export function inputUtility(element, space) {
+    switch (element.getAttribute("type")) {
+        case "text":
+            editType(element, space);
+            break;
+        case "color":
+            assignType(element, space);
+            break;
+        case "date":
+            assignType(element, space);
+            break;
+        case "time":
+            assignType(element, space);
+            break;
+        case "email":
+            editType(element, space);
+            break;
+        case "url":
+            editType(element, space);
+            break;
+        case "week":
+            assignType(element, space);
+            break;
+        case "tel":
+            editType(element, space);
+            break;
+        case "search":
+            editType(element, space);
+            break;
+        case "range":
+            assignType(element, space);
+            break;
+        case "radio":
+            assignType(element, space);
+            break;
+        case "password":
+            editType(element, space);
+            break;
+        case "number":
+            editType(element, space);
+            break;
+        case "month":
+            assignType(element, space);
+            break;
+        case "hidden":
+            editType(element, space);
+            break;
+        case "file":
+            filesType(element, space);
+            break;
+        case "datetime-local":
+            assignType(element, space);
+            break;
+        case "datetime":
+            assignType(element, space);
+            break;
+        case "checkbox":
+            assignType(element, space);
+            break;
+        default:
+            console.log("This type input can`t be tackled!");
+            break;
+    }
+}
+/**
+ *
+ * @param element
+ * @param space
+ */
+function assignType(element, space) {
+    Reflect.set(space, "origin", {
+        tag: element.tagName,
+        id: element.getAttribute("id"),
+    });
+}
+/**
+ *
+ * @param element
+ * @param space
+ */
+function editType(element, space) {
+    Reflect.set(space, "origin", {
+        tag: element.tagName,
+        id: element.getAttribute("id"),
+        // @ts-ignore
+        start: element.selectionStart
+    });
+}
+/**
+ *
+ * @param element
+ * @param space
+ */
+export function filesType(element, space) {
+    Reflect.set(space, "origin", {
+        tag: element.tagName,
+        id: element.getAttribute("id")
+    });
+}
+/**
+ *
+ * @param element
+ * @param space
+ */
+export function selectUtility(element, space) {
+    Reflect.set(space, "origin", {
+        tag: element.tagName,
+        id: element.getAttribute("id"),
+        // @ts-ignore
+        selected: element.value
+    });
+}
+/**
+ *
+ * @param element
+ * @param space
+ */
+export function textareaUtility(element, space) {
+    Reflect.set(space, "origin", {
+        tag: element.tagName,
+        id: element.getAttribute("id"),
+        // @ts-ignore
+        start: element.selectionStart
+    });
+}

package/system/utility/react/modelUtility.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This func used to make a flag to the input element
+ * @param evt
+ */
+export declare function compositionstart(evt: any): void;
+/**
+ * This func used to make a flag to the input element
+ * @param evt
+ */
+export declare function listener(evt: any): void;
+/**
+ * This func used to make a flag to the input element
+ * @param evt
+ */
+export declare function compositionend(evt: any): void;

package/system/utility/react/modelUtility.js

@@ -0,0 +1,64 @@
+import { inputUtility, selectUtility, textareaUtility } from "./inputUtility";
+/**
+ * This func used to make a flag to the input element
+ * @param evt
+ */
+export function compositionstart(evt) {
+    evt.target.setAttribute("flag", "false");
+}
+/**
+ * This func used to make a flag to the input element
+ * @param evt
+ */
+export function listener(evt) {
+    if (!evt.target.hasAttribute("flag")) {
+        //Get the event element
+        var element = evt.target;
+        switch (element.nodeName.toUpperCase()) {
+            case "INPUT":
+                inputUtility(element, this);
+                break;
+            case "SELECT":
+                selectUtility(element, this);
+                break;
+            case "TEXTAREA":
+                textareaUtility(element, this);
+                break;
+            default:
+                console.error("Can`t bind this type input tag!");
+                break;
+        }
+        //Update the value
+        if (element.type === "file")
+            this[element.name] = element.files;
+        else
+            this[element.name] = element.value;
+    }
+}
+/**
+ * This func used to make a flag to the input element
+ * @param evt
+ */
+export function compositionend(evt) {
+    evt.target.setAttribute("flag", "true");
+    //Get the event element
+    var element = evt.target;
+    //Get the name attribute
+    var dataName = element.name;
+    switch (element.nodeName.toUpperCase()) {
+        case "INPUT":
+            inputUtility(element, this);
+            break;
+        case "SELECT":
+            selectUtility(element, this);
+            break;
+        case "TEXTAREA":
+            textareaUtility(element, this);
+            break;
+        default:
+            console.error("Can`t bind this type input tag!");
+            break;
+    }
+    //Update the value
+    this[dataName] = element.value;
+}

package/system/utility/react/sectionUtility.d.ts

@@ -0,0 +1,6 @@
+import { ContextController } from "../../prototype/ContextController";
+/**
+ *
+ * @param controller
+ */
+export declare function locateInputAddress(controller: ContextController): void;