@jaisocx/tree 1.5.36 → 2.2.18

package/transpiled/Simple/typescript/TreeAdapter.js

@@ -0,0 +1,17 @@
+class TreeAdapter {
+    conf;
+    nodesWithIcons;
+    nodesOpenedMode;
+    dataTypesCssClassesEnabled;
+
+
+
+    constructor() {
+        this.conf = new TreeConf();
+        this.nodesWithIcons = TreeConstants.Defaults.nodesWithIcons;
+        this.nodesOpenedMode = TreeConstants.Defaults.nodesOpenedMode;
+        this.dataTypesCssClassesEnabled = TreeConstants.Defaults.dataTypesCssClassesEnabled;
+    }
+}
+
+

package/transpiled/Simple/typescript/TreeAdapterModeConf.js

@@ -0,0 +1,117 @@
+class TreeAdapterModeConf extends TreeAdapter {
+
+    getSubtreeNodeToRender(
+        _loopPropertyValue,
+        _loopPropertyKey
+    ) {
+        return _loopPropertyValue;
+    }
+
+
+
+    getDataForRendering(
+        node,
+        flatNodeClone,
+        dataTypeString,
+        hasSubtree
+    ) {
+        const SYMBOL_BACKGROUND_SPACE = String.fromCharCode(32);
+        let openButtonClassName = "";
+
+        if (!hasSubtree) {
+            openButtonClassName = TreeConstants.TreeCssClassNames.CLASS_WITHOUT_SUBTREE;
+
+
+            // @ts-ignore
+        }
+        else if ((this.nodesOpenedMode === TreeConstants.NodesOpenedMode.ALL_SHOWN)) {
+            openButtonClassName = TreeConstants.TreeCssClassNames.CLASS_OPENED;
+        }
+        else if ((node[this.conf.NODE__OPENED] === true)
+            && (this.nodesOpenedMode === TreeConstants.NodesOpenedMode.JSON_DATA_DEFINED)) {
+            openButtonClassName = TreeConstants.TreeCssClassNames.CLASS_OPENED;
+        }
+        const cssClasses = this.getTreeNodeCssClasses(dataTypeString, node);
+        let confImageSrc = node[this.conf.NODE_ICON__SRC] || "";
+        let isMiniImagesTagShown = this.nodesWithIcons;
+        let isConfImageSrc = (confImageSrc.length !== 0);
+        confImageSrc = (isMiniImagesTagShown && isConfImageSrc) ? confImageSrc : "";
+        isConfImageSrc = (isMiniImagesTagShown && isConfImageSrc);
+        let isMiniImageTagImg = (isMiniImagesTagShown && isConfImageSrc);
+        let tagImageCssClassnames = new Array();
+
+        if (isMiniImagesTagShown) {
+            tagImageCssClassnames.push(TreeConstants.TreeCssClassNames.CLASS_ICON_SHOW);
+        }
+        else {
+            tagImageCssClassnames.push(TreeConstants.TreeCssClassNames.CLASS_ICON_HIDE);
+        }
+
+        if (isMiniImageTagImg) {
+            tagImageCssClassnames.push(TreeConstants.TreeCssClassNames.CLASS_ICON_TAG_IMG);
+        }
+        const dataForRendering = {
+            dataId: node[this.conf.NODE__ID],
+            dataHolderId: node[this.conf.NODE__HOLDER_ID],
+            dataOrder: node[this.conf.NODE__ORDER],
+            dataJson: this.escapeHTMLForAttribute(JSON.stringify(flatNodeClone)),
+            openButtonStateClassName: openButtonClassName,
+            cssClasses,
+            iconSrc: confImageSrc,
+            iconShowClassName: tagImageCssClassnames.join(SYMBOL_BACKGROUND_SPACE),
+            labelText: node[this.conf.NODE_LABEL__TEXT],
+            hyperlink: node[this.conf.NODE__HYPERLINK] ?? "javascript: void(0);",
+            hasSubtree
+        };
+
+
+        return dataForRendering;
+    }
+
+
+
+    getTreeNodeCssClasses__dataTypesCssClassesEnabled(dataTypeString, node) {
+        const cssClassesNodeValue = node[this.conf.NODE__CSS_CLASS_NAME];
+        const cssClassesArray = [
+            ("class=\""),
+            (cssClassesNodeValue),
+            (" "),
+            (TreeConstants.TreeCssClassNames.PREFIX__CLASS_DATATYPE),
+            (dataTypeString),
+            ("\"")
+        ];
+        const cssClasses = cssClassesArray.join("");
+
+
+        return cssClasses;
+    }
+
+
+
+    getTreeNodeCssClasses__dataTypesCssClassesDisabled(_dataTypeString, _node) {
+        const cssClassesNodeValue = _node[this.conf.NODE__CSS_CLASS_NAME];
+        const cssClassesArray = [
+            ("class=\""),
+            (cssClassesNodeValue),
+            ("\"")
+        ];
+        const cssClasses = cssClassesArray.join("");
+
+
+        return cssClasses;
+    }
+
+
+    // dummy placeholders
+    escapeHTMLForAttribute(_arg) {
+        throw new Error("Method not implemented.");
+    }
+
+
+
+    getTreeNodeCssClasses(_dataTypeString, _value) {
+        throw new Error("Method not implemented.");
+    }
+}
+
+

package/transpiled/Simple/typescript/TreeAdapterModeEase.js

@@ -0,0 +1,87 @@
+class TreeAdapterModeEase extends TreeAdapter {
+
+    getSubtreeNodeToRender(
+        loopPropertyValue,
+        loopPropertyKey
+    ) {
+        const subtreeJsonNode = { [loopPropertyKey]: loopPropertyValue };
+
+
+        return subtreeJsonNode;
+    }
+
+
+
+    getDataForRendering(
+        node,
+        flatNodeClone,
+        dataTypeString,
+        nodeHasSubtree
+    ) {
+        const key = Object.keys(node)[0];
+        const value = node[key] ?? "";
+        let openButtonClassName = "";
+        let labelText = `"${key}"`;
+
+        if (!nodeHasSubtree) {
+            openButtonClassName = TreeConstants.TreeCssClassNames.CLASS_WITHOUT_SUBTREE;
+            const serializedJsonValue = this.escapeHTMLForAttribute(JSON.stringify(value));
+            labelText = `"${key}": ${serializedJsonValue}`;
+        }
+        else if (this.nodesOpenedMode === TreeConstants.NodesOpenedMode.ALL_SHOWN) {
+            openButtonClassName = TreeConstants.TreeCssClassNames.CLASS_OPENED;
+        }
+        const cssClasses = (this.dataTypesCssClassesEnabled === true) ? this.getTreeNodeCssClasses(dataTypeString, value) : "";
+        const dataForRendering = {
+            iconSrc: "",
+            iconShowClassName: this.nodesWithIcons ? "icon-show mode-ease" : "icon-hide",
+            labelText,
+            hyperlink: "javascript: void(0);",
+            cssClasses,
+            dataId: "",
+            dataHolderId: "",
+            dataOrder: "",
+            dataJson: this.escapeHTMLForAttribute(JSON.stringify(flatNodeClone)),
+            openButtonStateClassName: openButtonClassName,
+            hasSubtree: nodeHasSubtree
+        };
+
+
+        return dataForRendering;
+    }
+
+
+
+    getTreeNodeCssClasses__dataTypesCssClassesEnabled(_dataTypeString, _node) {
+        const cssClassesArray = [
+            ("class=\""),
+            (TreeConstants.TreeCssClassNames.PREFIX__CLASS_DATATYPE),
+            (_dataTypeString),
+            ("\"")
+        ];
+        const cssClasses = cssClassesArray.join("");
+
+
+        return cssClasses;
+    }
+
+
+
+    getTreeNodeCssClasses__dataTypesCssClassesDisabled(_dataTypeString, _node) {
+        throw new Error("Method not implemented.");
+    }
+
+
+    // dummy placeholders
+    escapeHTMLForAttribute(_arg) {
+        throw new Error("Method not implemented.");
+    }
+
+
+
+    getTreeNodeCssClasses(_dataTypeString, _value) {
+        throw new Error("Method not implemented.");
+    }
+}
+
+

package/transpiled/Simple/typescript/TreeConf.js

@@ -0,0 +1,31 @@
+class TreeConf {
+    NODE_ICON__SRC;
+    NODE_LABEL__TEXT;
+    SUBTREE;
+    NODE__ID;
+    NODE__HOLDER_ID;
+    NODE__PATH;
+    NODE__ORDER;
+    NODE__HYPERLINK;
+    NODE__OPENED;
+    NODE__CSS_CLASS_NAME;
+    NODE__ART;
+
+
+
+    constructor() {
+        this.NODE_ICON__SRC = "icon";
+        this.NODE_LABEL__TEXT = "label";
+        this.SUBTREE = "subtree";
+        this.NODE__ID = "id";
+        this.NODE__HOLDER_ID = "holderId";
+        this.NODE__PATH = "PATH";
+        this.NODE__ORDER = "order";
+        this.NODE__HYPERLINK = "href";
+        this.NODE__OPENED = "opened";
+        this.NODE__CSS_CLASS_NAME = "cssClassName";
+        this.NODE__ART = "art";
+    }
+}
+
+

package/{build/ESNext → transpiled/Simple}/typescript/TreeConstants.js

@@ -1,12 +1,12 @@
-export class TreeConstants {
+class TreeConstants {
     static RenderingMode = {
         Ease: 1,
-        Conf: 2,
+        Conf: 2
     };
     static NodesOpenedMode = {
         ALL_SHOWN: 1,
         JSON_DATA_DEFINED: 2,
-        ALL_HIDE: 3,
+        ALL_HIDE: 3
     };
     static TreeCssClassNames = {
         MAIN_CLASS_NAME: "tree",
@@ -15,23 +15,25 @@ export class TreeConstants {
         CLASS_WITHOUT_SUBTREE: "toggle-without-subtree",
         CLASS_ICON_SHOW: "icon-show",
         CLASS_ICON_HIDE: "icon-hide",
+        CLASS_ICON_TAG_IMG: "icon-tag-img",
         CLASS_AND_ID__CONTEXT_MENU: "context-menu-container",
         CLASS_DATATYPE_OBJECT: "holder-datatype--object",
         CLASS_DATATYPE_ARRAY: "holder-datatype--array",
         CLASS_DATATYPE_STRING: "holder-datatype--string",
         CLASS_DATATYPE_NUMBER: "holder-datatype--number",
         CLASS_DATATYPE_BOOLEAN: "holder-datatype--boolean",
-        PREFIX__CLASS_DATATYPE: "holder-datatype--",
+        PREFIX__CLASS_DATATYPE: "holder-datatype--"
     };
     static TreeEventsNames = {
+        EVENT_NAME__BEFORE_RENDER_ONE_NODE: "beforeRenderOneNode",
         EVENT_NAME__AFTER_RENDER_ONE_NODE: "afterRenderOneNode",
         EVENT_NAME__TREE_NODE_EXPAND_BUTTON__CLICK: "openButtonClick",
-        EVENT_NAME__TREE_NODE_LABEL__CLICK: "treeNodeLabelClick",
+        EVENT_NAME__TREE_NODE_LABEL__CLICK: "treeNodeLabelClick"
     };
     static TEMPLATE__TREE_HTML_NODE = `
-<li 
-    data-id="{{ dataId }}" 
-    data-holder-id="{{ dataHolderId }}" 
+<li
+    data-id="{{ dataId }}"
+    data-holder-id="{{ dataHolderId }}"
     data-order="{{ dataOrder }}"
     {{ cssClasses }}>
 
@@ -44,14 +46,14 @@ export class TreeConstants {
         </pre>
 
         <pre class="jstree-html-node-holder-icon {{ iconShowClassName }}">
-            <img src="{{ iconSrc }}" />
+            <img src="{{ iconSrc }}" alt="Mini image {{ dataId }}" />
         </pre>
 
         <a href="{{ hyperlink }}" class="jstree-html-node-label">{{ labelText }}</a>
     </pre>
-    
+
     <ul></ul>
-</li>        
+</li>
         `;
     static Defaults = {
         debug: false,
@@ -59,7 +61,8 @@ export class TreeConstants {
         nodesWithIcons: true,
         nodesOpenedMode: TreeConstants.NodesOpenedMode.ALL_HIDE,
         isModifiable: false,
-        dataTypesCssClassesEnabled: true,
+        dataTypesCssClassesEnabled: true
     };
 }
-//# sourceMappingURL=TreeConstants.js.map
+
+

package/transpiled/Simple/typescript/Types.js

@@ -0,0 +1,4 @@
+export {};
+
+
+//# sourceMappingURL=Types.js.map

package/transpiled/Simple/webpack.aliases.cjs

@@ -0,0 +1,19 @@
+"use strict";
+// the hardcoded copy of .cjs file
+const fs = require("node:fs");
+const path = require("node:path");
+const getWebpackAliases = require("./webpackAliases.js");
+// Get the filename and directory in a CommonJS-compatible way
+const fileName = __filename;
+const currentDir = path.resolve(__dirname);
+const projectRoot = path.resolve(currentDir, "../../../");
+let webpackAliasesResolved = getWebpackAliases(projectRoot);
+// Exporting the WebpackAliases object
+module.exports = {
+  WebpackAliases: {
+    resolve: {
+      alias: { ...webpackAliasesResolved },
+    },
+  },
+};
+//# sourceMappingURL=webpack.aliases.cjs.map

package/transpiled/Simple/webpack.aliases.mjs

@@ -0,0 +1,14 @@
+// the hardcoded copy of .mjs file
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getWebpackAliases } from "./webpackAliases.js";
+let fileName = fileURLToPath(import.meta.url);
+let currentDir = path.resolve(fileName);
+let projectRoot = path.resolve(currentDir, "../../../");
+let webpackAliasesResolved = getWebpackAliases(projectRoot);
+export let WebpackAliases = {
+  resolve: {
+    alias: { ...webpackAliasesResolved },
+  },
+};
+//# sourceMappingURL=webpack.aliases.mjs.map

package/transpiled/Simple/webpackAliases.js

@@ -0,0 +1,44 @@
+// the hardcoded copy of .ts file
+import * as path from "node:path";
+import * as fs from "node:fs";
+export function getWebpackAliases(packageRoot) {
+    const PROJECT_ROOT_PLACEHOLDER = "${packageRoot}/";
+    const WEBPACK_ALIASES_JSON__FILENAME = "webpack.aliases.json";
+    const WEBPACK_ALIASES_JSON__CHARSET = "utf8";
+    const CHAR_ZERO_LEN = "";
+    const webpackAliasesJsonPath = path.resolve(
+        packageRoot,
+        WEBPACK_ALIASES_JSON__FILENAME
+    );
+
+
+    // Read and parse the JSON file
+    const json = fs.readFileSync(
+        webpackAliasesJsonPath,
+        WEBPACK_ALIASES_JSON__CHARSET
+    );
+    const aliases = JSON.parse(json);
+    console.info(aliases);
+    const webpackAliasesResolved = {};
+
+    for (const propName in aliases) {
+        const aliasPath = aliases[propName];
+        const pathReplaced = aliasPath.replace(
+            PROJECT_ROOT_PLACEHOLDER,
+            CHAR_ZERO_LEN
+        );
+        const pathResolved = path.resolve(packageRoot, pathReplaced);
+        webpackAliasesResolved[propName] = pathResolved;
+    }
+
+
+    // let webpackAliases = {
+    //   resolve: {
+    //     alias: { ...webpackAliasesResolved },
+    //   },
+    // };
+    return webpackAliasesResolved;
+}
+
+
+//# sourceMappingURL=webpackAliases.js.map