ru.coon 3.0.85 → 3.0.88

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# Version 3.0.88, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/a72099d6e504067f855a039fa59064412650d2ed)
+* ## Features
+* <span style='color:green'>feat: restore initial sort order(HT-15548)</span> ([1e05ed], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/1e05ed4fa8c952cedb098ac7f22d8bff75ee76e1))
+
+* upd ([f528fe], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/f528fef7cfbc8dbf082e87aa25178591ab070673))
+* update: CHANGELOG.md ([266027], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/2660273ba4d148d6533d409f99b5f55038ec1d25))
+
+# Version 3.0.87, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/2f65647d7dc56cc63610f4dcd70c765c1ec25a35)
+* ## Fixes
+* <span style='color:red'> HT-10298 Доработка внешнего вида NoteEditorCreator</span> ([4f14da], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/4f14da33f15fc83b19cabf83cc1ba51814f656bf))
+
+* upd ([20e397], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/20e397d293e06e79c40860b952d1b067cc90369a))
+* upd ([970ad4], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/970ad4a00fe880c845f0631f84b4470beba87229))
+* update: CHANGELOG.md ([b6f217], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/b6f2171d4910b5b355a338c3aad366771e023629))
+
+# Version 3.0.86, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/a568914d31b78421977a33a435390084439a1778)
+* ## Fixes
+* <span style='color:red'>fix</span> ([36dceb], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/36dcebbe4096ea1b91d82a7e9cdffaccb1d38cc8))
+
+* update: CHANGELOG.md ([dbde81], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/dbde8119310c7536df00629a3be387bb1d88cd39))
+
 # Version 3.0.85, [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/d03e2cb1d340c80862f949a561196d650d1b720a)
 * ## Fixes
 * <span style='color:red'>fix</span> ([0c1ddd], [link](http://gitlab-dbr.sigma-it.local/dbr/ru.coon/-/commit/0c1dddad599b412a7c363398f70bcecdb295ca32))

package/package.json

@@ -4,7 +4,7 @@
     "name": "ru.coon"
   },
   "description": "",
-  "version": "3.0.85",
+  "version": "3.0.88",
   "repository": {
     "type": "git",
     "url": "git+http://gitlab-dbr.sigma-it.local/dbr/ru.coon"

package/src/common/component/editor/creators/NoteEditorCreator.js

@@ -22,9 +22,19 @@ Ext.define('Coon.common.component.editor.creators.NoteEditorCreator', {
 
     showPanel: function(record, parent) {
         this.noteID = record.get('value');
-        this.textField = Ext.create({
+        this.textTypeField = Ext.create({
+            xtype: 'textfield',
+            fieldLabel: 'Характеристика',
+            editable: false,
+            cls: 'no-input-border-bottom',
+            width: '100%',
+            value: record.get('typeDescription'),
+        }),
+        this.textValueField = Ext.create({
             xtype: 'textarea',
+            fieldLabel: 'Значение',
             width: '99%',
+            flex: 1,
             maxLength: 4000,
             maxLengthText: 'Максимальная допустимая длина поля - 4000 символов',
         });
@@ -32,14 +42,17 @@ Ext.define('Coon.common.component.editor.creators.NoteEditorCreator', {
         if (!Ext.isEmpty(this.noteID)) {
             const command = Ext.create('Coon.common.command.GetNoteCommand');
             command.on('complete', function(response) {
-                this.textField.setValue(response.text);
+                this.textValueField.setValue(response.text);
             }, this);
             command.execute(this.noteID);
         }
         const textPanel = new Ext.Panel({
-            layout: 'fit',
+            layout: 'vbox',
             padding: 10,
-            items: this.textField,
+            items: [
+                this.textTypeField,
+                this.textValueField
+            ],
         });
 
         const win = this.win = Ext.widget('WindowWrap', {
@@ -70,16 +83,16 @@ Ext.define('Coon.common.component.editor.creators.NoteEditorCreator', {
                 ],
             }],
 
-            title: 'Редактирование характеристики ' + record.get('typeDescription'),
+            title: 'Редактирование характеристики',
         });
         return this.win;
     },
 
     saveValue: function(record, parent) {
-        if (!this.textField.validate()) {
+        if (!this.textValueField.validate()) {
             return;
         }
-        if (Ext.isEmpty(this.textField.getValue().trim())) {
+        if (Ext.isEmpty(this.textValueField.getValue().trim())) {
             this.noteID = '';
             this.setValueInField(record, parent);
         } else {
@@ -88,13 +101,13 @@ Ext.define('Coon.common.component.editor.creators.NoteEditorCreator', {
                 this.noteID = response.noteId;
                 this.setValueInField(record, parent);
             }, this);
-            saveCommand.execute(this.noteID, this.textField.getValue());
+            saveCommand.execute(this.noteID, this.textValueField.getValue());
         }
     },
 
     setValueInField(record, parent) {
-        const value = this.textField.getValue().trim() ? this.getValue() : '';
-        const description = this.textField.getValue();
+        const value = this.textValueField.getValue().trim() ? this.getValue() : '';
+        const description = this.textValueField.getValue();
         record.set('value', value);
         record.set('valueDescription', description);
         this.field.setVisibleValue(description);

package/src/report/component/reportpanel/ReportGrid.js

@@ -30,7 +30,17 @@ Ext.define('Coon.report.component.reportpanel.ReportGrid', {
      */
     bodyCls: 'enable-striped-rows',
 
+    locals: {},
+
     initComponent: function() {
+        const self = this;
+        this.fields.push({
+            name: '__initialSortOrder',
+            convert(_, record) {
+                record.data.__initialSortOrder = self.locals.initialOrderIndex;
+                self.locals.initialOrderIndex += 1;
+            },
+        });
         this.store = Ext.create('Coon.report.component.reportpanel.ReportStore', {
             fields: this.fields,
             groupField: this.groupField,
@@ -42,6 +52,10 @@ Ext.define('Coon.report.component.reportpanel.ReportGrid', {
             pageSize: this.pageSize,
         });
 
+        this.store.on('beforeload', function() {
+            this.locals.initialOrderIndex = 0;
+        }, this);
+
         this.on('afterrender', () => {
             this.doAutoSizeAllColumn();
             this.store.on('load', () => {
@@ -79,6 +93,28 @@ Ext.define('Coon.report.component.reportpanel.ReportGrid', {
         this.callParent();
         this.relayEvents(this.getStore(), ['datachanged', 'load']);
         this.increaseToolbarHeight();
+        this.addRestoreSortingMenuItem();
+    },
+
+    addRestoreSortingMenuItem() {
+        const menu = this.getHeaderContainer?.().getMenu?.();
+        if (!menu) {
+            return;
+        }
+        const menuItem = menu.add({
+            text: 'отменить сортировку',
+            handler: this.restoreInitianSorting.bind(this),
+        });
+        menu.moveAfter(menuItem, menu.getComponent(1));
+        menu.on('beforeshow', function(menu) {
+            const column = menu.ownerCmp;
+            menuItem.setDisabled(!column.sortable);
+        });
+    },
+
+    restoreInitianSorting() {
+        this.store.getSorters().remove();
+        this.store.sort('__initialSortOrder', 'ASC');
     },
 
     /**

package/src/report/component/reportpanel/ReportTree.js

@@ -21,6 +21,7 @@ Ext.define('Coon.report.component.reportpanel.ReportTree', {
         treeColumnIndex: 'TREE_ELEMENT_TEXT',
         treeReducers: [],
         checkedRecords: [],
+        enableAutoSize: false,
     },
 
     /**
@@ -38,6 +39,9 @@ Ext.define('Coon.report.component.reportpanel.ReportTree', {
         this.getColumnModel = Ext.bind(Ext.grid.Panel.prototype.getColumnModel, this);
         const me = this;
         this.plugins = [].concat(this.plugins || [], 'GridRecordViewerPlugin');
+        this.on('afterrender', () => {
+            this.doAutoSizeAllColumn();
+        }, this, {single: true});
         this.store = Ext.create('Coon.report.component.reportpanel.ReportTreeStore', {
             fields: this.fields,
             groupField: this.groupField,
@@ -117,9 +121,20 @@ Ext.define('Coon.report.component.reportpanel.ReportTree', {
                     Ext.Component.generateTestId(store.getAt(index).get(this.idIndex), domElement);
                 }
             }
+            this.doAutoSizeAllColumn();
         }, this);
     },
 
+    doAutoSizeAllColumn() {
+        if (
+            this.getEnableAutoSize() &&
+            typeof this.getColumnModel === 'function' &&
+            typeof this.getColumnModel().autoSizeAllColumn === 'function'
+        ) {
+            this.getColumnModel().autoSizeAllColumn();
+        }
+    },
+
     clear: function() {
         if (this.rendered) {
             this.getSelectionModel().clearSelections();

package/src/uielement/plugin/OpenPanelPlugin.js

@@ -29,12 +29,8 @@ Ext.define('Coon.uielement.plugin.OpenPanelPlugin', {
             Coon.log.error('OpenPanelPlugin.init: viewModel is required');
             return;
         }
-        if (!this.config.uiElementCd) {
-            Coon.log.error('OpenPanelPlugin.init: uiElementCd is required');
-            return;
-        }
-        if (!this.config.panelXType) {
-            Coon.log.error('OpenPanelPlugin.init: panelXType is required');
+        if (!this.config.uiElementCd && !this.config.panelXType) {
+            Coon.log.error('OpenPanelPlugin.init: uiElementCd||panelXType is required');
             return;
         }
         this.initialized = true;

package/src/version.js

@@ -1,4 +1,4 @@
 Ext.define('Coon.version', {
     singleton: true,
-    number: '3.0.85',
+    number: '3.0.88',
 });

package/AGENTS.md

@@ -1,26 +0,0 @@
-# Project Name
-
-core of ExtJS 7 extensive expandable components
-
-## Code Style
-
-- Follow ESLint configuration
-- Use 2 spaces for indentation
-- one file for one class
-
-## Architecture
-
-- Follow DRY pattern
-- Keep components under 200 lines
-- Use dependency injection
-
-## Testing
-
-- Write unit tests for all business logic
-- Maintain >80% code coverage
-- Use Jest for testing
-
-## Security
-
-- Never commit API keys or secrets
-- Validate all user inputs

package/src/IndentTemplate.js

@@ -1,324 +0,0 @@
-/* eslint-disable require-jsdoc */
-/**
- * A template engine that uses indentation-based syntax to define structure,
- * supporting mixins, loops, and variable interpolation.
- */
-class IndentTemplate {
-    /**
-     * Creates a new IndentTemplate instance.
-     * @param {string} [template=''] - The initial template string
-     */
-    constructor(template = '') {
-        this._template = template;
-        this._ast = null;
-        this._mixins = {};
-    }
-
-    /**
-     * Sets or changes the template string.
-     * @param {string} template - The template string to set
-     * @returns {IndentTemplate} This instance for chaining
-     */
-    setTemplate(template) {
-        this._template = template;
-        this._ast = null;
-        this._mixins = {};
-        return this; // chainable
-    }
-
-    /**
-     * Compiles the template by parsing it into an AST and collecting mixins.
-     * @returns {IndentTemplate} This instance for chaining
-     * @throws {Error} If the template is empty or has invalid syntax
-     */
-    compile() {
-        if (!this._template) {
-            throw new Error('Шаблон пуст. Используй setTemplate(template).');
-        }
-
-        const rawLines = this._template
-            .split('\n')
-            .map((l) => l.replace(/\r$/, ''))
-            .filter((l) => l.trim().length > 0);
-
-        const lines = rawLines.map((line) => {
-            const m = line.match(/^(\s*)/);
-            const indent = m ? m[1].length : 0;
-            const level = Math.floor(indent / 2); // 2 пробела = 1 уровень
-            return {
-                level,
-                content: line.trim(),
-            };
-        });
-
-        this._mixins = {};
-        let index = 0;
-
-        const parseBlock = (expectedLevel) => {
-            const nodes = [];
-
-            while (index < lines.length) {
-                const {level, content} = lines[index];
-
-                if (level < expectedLevel) {
-                    break;
-                }
-                if (level > expectedLevel) {
-                    // некорректный отступ — считаем конец этого блока
-                    break;
-                }
-
-                // ---- миксин определение ------------------------------------
-                if (content.startsWith('@mixin ')) {
-                    if (expectedLevel !== 0) {
-                        throw new Error('@mixin должен быть на верхнем уровне без отступов');
-                    }
-
-                    const def = content.slice(7).trim(); // после "@mixin "
-                    const parts = def.split(/\s+/);
-                    const name = parts[0];
-                    const params = parts.slice(1); // список имён параметров
-
-                    index++;
-                    // тело миксина — блок на уровне 1
-                    const body = parseBlock(expectedLevel + 1);
-
-                    this._mixins[name] = {params, body};
-                    continue; // миксин не попадает в основной AST
-                }
-
-                // ---- цикл @for ---------------------------------------------
-                if (content.startsWith('@for ')) {
-                    const forLine = content.slice(5).trim(); // убираем "@for "
-                    const match = forLine.match(/^(\w+)\s+in\s+(.+)$/);
-                    if (!match) {
-                        throw new Error('Неверный синтаксис @for: ' + content);
-                    }
-                    const varName = match[1];
-                    const listExpr = match[2].trim();
-
-                    index++;
-                    const children = parseBlock(expectedLevel + 1);
-
-                    nodes.push({
-                        type: 'for',
-                        varName,
-                        listExpr,
-                        children,
-                    });
-                    continue;
-                }
-
-                // ---- использование миксина: @use name(arg1, arg2) ----------
-                if (content.startsWith('@use ')) {
-                    const call = content.slice(5).trim();
-                    const m = call.match(/^(\w+)\s*\((.*)\)$/);
-                    if (!m) {
-                        throw new Error('Неверный синтаксис @use: ' + content);
-                    }
-                    const mixinName = m[1];
-                    const argsRaw = m[2].trim();
-                    const argExprs = argsRaw ?
-                        argsRaw.split(',').map((s) => s.trim()) :
-                        [];
-
-                    index++;
-
-                    nodes.push({
-                        type: 'use',
-                        mixinName,
-                        argExprs,
-                    });
-                    continue;
-                }
-
-                // ---- обычный тег -------------------------------------------
-                const [tag, ...restParts] = content.split(/\s+/);
-                const text = restParts.join(' ');
-                const selfClosing = new Set(['br', 'hr', 'img', 'input', 'meta', 'link']);
-                const lowerTag = tag.toLowerCase();
-                const isSelfClosing = selfClosing.has(lowerTag);
-
-                index++;
-
-                let children = [];
-                if (!text && !isSelfClosing && index < lines.length) {
-                    const next = lines[index];
-                    if (next.level > expectedLevel) {
-                        children = parseBlock(expectedLevel + 1);
-                    }
-                }
-
-                nodes.push({
-                    type: 'tag',
-                    tag,
-                    text,
-                    isSelfClosing,
-                    children,
-                });
-            }
-
-            return nodes;
-        };
-
-        this._ast = parseBlock(0);
-        return this; // chainable
-    }
-
-    /**
-     * Builds the final HTML output by rendering the compiled template with provided data.
-     * @param {Object} [data={}] - The data object to render the template with
-     * @returns {string} The rendered HTML string
-     */
-    build(data = {}) {
-        if (!this._ast) {
-            this.compile();
-        }
-        return this._renderNodes(this._ast, data);
-    }
-
-    // ===================== RENDER =====================
-
-    /**
-     * Renders an array of nodes with the given scope.
-     * @param {Array} nodes - Array of AST nodes to render
-     * @param {Object} scope - The current scope/data context
-     * @returns {string} Concatenated rendered nodes
-     * @private
-     */
-    _renderNodes(nodes, scope) {
-        return nodes.map((node) => this._renderNode(node, scope)).join('');
-    }
-
-    /**
-     * Renders a single node based on its type.
-     * @param {Object} node - The AST node to render
-     * @param {Object} scope - The current scope/data context
-     * @returns {string} The rendered HTML for this node
-     * @private
-     */
-    _renderNode(node, scope) {
-    // for
-        if (node.type === 'for') {
-            const list = this._resolvePath(scope, node.listExpr);
-            if (!Array.isArray(list) || list.length === 0) {
-                return '';
-            }
-            let out = '';
-            for (const item of list) {
-                const childScope = Object.create(scope);
-                childScope[node.varName] = item;
-                out += this._renderNodes(node.children, childScope);
-            }
-            return out;
-        }
-
-        // use mixin
-        if (node.type === 'use') {
-            const def = this._mixins[node.mixinName];
-            if (!def) {
-                throw new Error(`Миксин "${node.mixinName}" не найден`);
-            }
-
-            const {params, body} = def;
-            const argValues = node.argExprs.map((expr) => this._resolvePath(scope, expr));
-
-            const childScope = Object.create(scope);
-            params.forEach((name, i) => {
-                childScope[name] = argValues[i];
-            });
-
-            return this._renderNodes(body, childScope);
-        }
-
-        // обычный тег
-        if (node.type === 'tag') {
-            const {tag, text, isSelfClosing, children} = node;
-
-            if (isSelfClosing) {
-                return `<${tag}>`;
-            }
-
-            const innerText = text ?
-                this._renderTextWithTemplates(text, scope) :
-                '';
-
-            const childrenHtml = children && children.length ?
-                this._renderNodes(children, scope) :
-                '';
-
-            return `<${tag}>${innerText}${childrenHtml}</${tag}>`;
-        }
-
-        return '';
-    }
-
-    /**
-     * Renders text with template expressions replaced by values from scope.
-     * @param {string} text - Text potentially containing template expressions
-     * @param {Object} scope - The current scope/data context
-     * @returns {string} Text with expressions replaced by values
-     * @private
-     */
-    _renderTextWithTemplates(text, scope) {
-        let result = '';
-        let lastIndex = 0;
-        const regex = /\{\{([^}]+)\}\}/g;
-
-        text.replace(regex, (match, expr, offset) => {
-            // статичный кусок до {{ ... }}
-            const staticPart = text.slice(lastIndex, offset);
-            result += this._escape(staticPart);
-
-            const value = this._resolvePath(scope, expr.trim());
-            const strVal = value == null ? '' : String(value);
-            result += this._escape(strVal);
-
-            lastIndex = offset + match.length;
-            return '';
-        });
-
-        // хвост после последнего {{ ... }}
-        const tail = text.slice(lastIndex);
-        result += this._escape(tail);
-
-        return result;
-    }
-
-    /**
-     * Resolves a dot-notation path in the scope object.
-     * @param {Object} scope - The scope object to look in
-     * @param {string} path - Dot-notation path like "user.name"
-     * @returns {*} The resolved value or undefined
-     * @private
-     */
-    _resolvePath(scope, path) {
-        if (!path) {
-            return undefined;
-        }
-        const parts = path.split('.');
-        let value = scope;
-        for (const part of parts) {
-            if (value == null) {
-                return undefined;
-            }
-            value = value[part];
-        }
-        return value;
-    }
-
-    /**
-     * Escapes HTML special characters in text.
-     * @param {string} text - Text to escape
-     * @returns {string} Escaped text
-     * @private
-     */
-    _escape(text) {
-        return String(text)
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;');
-    }
-}
-
-export default IndentTemplate;

package/src/Template.js

@@ -1,420 +0,0 @@
-/**
- * A template engine that parses and compiles templates with custom syntax.
- * Supports elements, mixins, loops, conditions, and variable interpolation.
- */
-class Template {
-    /**
-     * Creates a new Template instance.
-     * @param {string} source - The template source string
-     */
-    constructor(source) {
-        this.source = source;
-        this.ast = this.parse(source);
-        this.renderFn = this.compile(this.ast);
-    }
-
-    /**
-     * Builds the final output by rendering the compiled template with provided context.
-     * @param {Object} context - The context object to render the template with
-     * @returns {string} The rendered output string
-     */
-    build(context = {}) {
-        return this.renderFn(context);
-    }
-
-    // ========== ПАРСЕР ==========
-
-    /**
-     * Parses the template source into an Abstract Syntax Tree (AST).
-     * @param {string} source - The template source string
-     * @returns {Object} The parsed AST representation
-     */
-    parse(source) {
-        const lines = source.split('\n').filter((line) => line.trim() !== '');
-        const mixins = new Map();
-        const {nodes} = this.parseBlock(lines, 0, 0, mixins);
-        return {type: 'Root', children: nodes, mixins};
-    }
-
-    /**
-     * Parses a block of lines at a specific indentation level.
-     * @param {string[]} lines - Array of template lines
-     * @param {number} start - Starting index in the lines array
-     * @param {number} indentLevel - Current indentation level
-     * @param {Map} mixins - Map of defined mixins
-     * @returns {Object} Object containing parsed nodes and the next index
-     */
-    parseBlock(lines, start, indentLevel, mixins) {
-        const nodes = [];
-        let i = start;
-
-        while (i < lines.length) {
-            const line = lines[i];
-            const match = line.match(/^ */);
-            const currentIndent = match ? match[0].length : 0;
-
-            if (currentIndent < indentLevel) {
-                break;
-            }
-            if (currentIndent !== indentLevel) {
-                throw new Error(`Invalid indentation at line ${i + 1}. Expected ${indentLevel}, got ${currentIndent}.`);
-            }
-
-            const content = line.trim();
-            let node;
-
-            if (content.startsWith('@mixin ')) {
-                const mixin = this.parseMixinDecl(content);
-                const {nodes: body, nextIndex} = this.parseBlock(lines, i + 1, indentLevel + 2, mixins);
-                mixin.body = body;
-                mixins.set(mixin.name, mixin);
-                node = mixin;
-                i = nextIndex;
-            } else if (content.startsWith('@use ')) {
-                const call = this.parseMixinCall(content);
-                const def = mixins.get(call.name);
-                if (!def) {
-                    throw new Error(`Undefined mixin: ${call.name}`);
-                }
-                node = {type: 'MixinCall', definition: def, args: call.args};
-                i++;
-            } else if (content.startsWith('@each ')) {
-                const each = this.parseEach(content);
-                const {nodes: body, nextIndex} = this.parseBlock(lines, i + 1, indentLevel + 2, mixins);
-                each.children = body;
-                node = each;
-                i = nextIndex;
-            } else if (content.startsWith('@if ')) {
-                const condition = content.slice(4).trim();
-                const ifNode = {type: 'If', condition, thenBranch: [], elseBranch: []};
-                const {nodes: thenBody, nextIndex: afterThen} = this.parseBlock(lines, i + 1, indentLevel + 2, mixins);
-                ifNode.thenBranch = thenBody;
-                i = afterThen;
-
-                // Проверяем, есть ли @else сразу после
-                if (i < lines.length) {
-                    const elseLine = lines[i].trim();
-                    const elseIndent = lines[i].match(/^ */)[0].length;
-                    if (elseIndent === indentLevel && elseLine === '@else') {
-                        const {nodes: elseBody, nextIndex: afterElse} = this.parseBlock(lines, i + 1, indentLevel + 2, mixins);
-                        ifNode.elseBranch = elseBody;
-                        i = afterElse;
-                    }
-                }
-
-                node = ifNode;
-            } else {
-                node = this.parseElement(content);
-                const {nodes: children, nextIndex} = this.parseBlock(lines, i + 1, indentLevel + 2, mixins);
-                node.children = children;
-                i = nextIndex;
-            }
-
-            if (node.type !== 'MixinDecl') {
-                nodes.push(node);
-            }
-        }
-
-        return {nodes, nextIndex: i};
-    }
-
-    /**
-     * Parses an element line into a structured object.
-     * @param {string} line - A line containing an element definition
-     * @returns {Object} Parsed element object
-     */
-    parseElement(line) {
-        const tagMatch = line.match(/^([a-zA-Z][a-zA-Z0-9]*)\b/);
-        if (!tagMatch) {
-            throw new Error(`Invalid tag: "${line}"`);
-        }
-        const tagName = tagMatch[1];
-        const rest = line.slice(tagMatch[0].length).trim();
-
-        const selfClosingTags = new Set([
-            'img', 'br', 'hr', 'input', 'meta', 'link', 'area', 'base', 'col', 'embed', 'source', 'track', 'wbr'
-        ]);
-
-        const attrs = {};
-        let text = '';
-
-        // Простой парсинг: всё, что содержит = → атрибут; остальное — текст
-        const tokens = rest.match(/(?:[^"\s=]+|"[^"]*")+/g) || [];
-        let inAttrs = true;
-        for (const t of tokens) {
-            if (t.includes('=')) {
-                const [key, val] = t.split('=', 2);
-                let finalVal = val;
-                if ((val.startsWith('"') && val.endsWith('"')) ||
-            (val.startsWith('\'') && val.endsWith('\''))) {
-                    finalVal = val.slice(1, -1);
-                }
-                attrs[key] = finalVal;
-            } else if (inAttrs && !t.startsWith('"') && !t.includes('{{')) {
-                // Предполагаем, что это булев атрибут
-                attrs[t] = true;
-            } else {
-                inAttrs = false;
-                if (text) {
-                    text += ' ';
-                }
-                text += t;
-            }
-        }
-
-        return {
-            type: 'Element',
-            tagName,
-            attrs,
-            text,
-            children: [],
-            selfClosing: selfClosingTags.has(tagName),
-        };
-    }
-
-    /**
-     * Parses a mixin declaration line.
-     * @param {string} line - A line containing a mixin declaration
-     * @returns {Object} Parsed mixin declaration object
-     */
-    parseMixinDecl(line) {
-        const match = line.match(/^@mixin\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([^)]*)\)/);
-        if (!match) {
-            throw new Error(`Invalid mixin declaration: ${line}`);
-        }
-        const name = match[1];
-        const params = match[2].split(',').map((p) => p.trim()).filter((p) => p);
-        return {type: 'MixinDecl', name, params, body: []};
-    }
-
-    /**
-     * Parses a mixin call line.
-     * @param {string} line - A line containing a mixin call
-     * @returns {Object} Parsed mixin call object
-     */
-    parseMixinCall(line) {
-        const match = line.match(/^@use\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([^)]*)\)/);
-        if (!match) {
-            throw new Error(`Invalid mixin call: ${line}`);
-        }
-        const name = match[1];
-        const argsStr = match[2];
-
-        const args = [];
-        let current = '';
-        let inQuote = null;
-        for (let k = 0; k < argsStr.length; k++) {
-            const c = argsStr[k];
-            if (c === inQuote) {
-                inQuote = null;
-            } else if (!inQuote && (c === '"' || c === '\'')) {
-                inQuote = c;
-            } else if (!inQuote && c === ',') {
-                args.push(current.trim());
-                current = '';
-                continue;
-            }
-            current += c;
-        }
-        if (current.trim()) {
-            args.push(current.trim());
-        }
-
-        return {type: 'MixinCall', name, args};
-    }
-
-    /**
-     * Parses an each loop declaration.
-     * @param {string} line - A line containing an each loop declaration
-     * @returns {Object} Parsed each loop object
-     */
-    parseEach(line) {
-        const match = line.match(/^@each\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+in\s+([a-zA-Z_][a-zA-Z0-9_.]*)/);
-        if (!match) {
-            throw new Error(`Invalid @each: ${line}`);
-        }
-        return {type: 'Each', iterator: match[1], collection: match[2], children: []};
-    }
-
-    // ========== КОМПИЛЯТОР ==========
-
-    /**
-     * Compiles the AST into a render function.
-     * @param {Object} ast - The Abstract Syntax Tree to compile
-     * @returns {Function} A function that renders the template with a given context
-     */
-    compile(ast) {
-        const code = this.generateCode(ast);
-        return new Function('ctx', `
-      const escape = (s) => {
-        if (s == null) return '';
-        return String(s)
-          .replace(/&/g, '&amp;')
-          .replace(/</g, '&lt;')
-          .replace(/>/g, '&gt;')
-          .replace(/"/g, '&quot;')
-          .replace(/'/g, '&#039;');
-      };
-      with(ctx || {}) {
-        return ${code};
-      }
-    `);
-    }
-
-    /**
-     * Generates JavaScript code from the AST nodes.
-     * @param {Object} node - The AST node to generate code for
-     * @returns {string} Generated JavaScript code as a string
-     */
-    generateCode(node) {
-        switch (node.type) {
-        case 'Root':
-            return node.children.map((child) => this.generateCode(child)).join(' + ') || '""';
-
-        case 'Element':
-            const {tagName, attrs, text, children: nodeChildren, selfClosing} = node;
-            let attrStr = '';
-            for (const [key, val] of Object.entries(attrs)) {
-                if (val === true) {
-                    attrStr += ` ${key}`;
-                } else {
-                    const expr = this.interpolateToExpr(val, true);
-                    attrStr += ` ${key}="\${${expr}}}`;
-                }
-            }
-
-            const textExpr = text ? this.interpolateToExpr(text, false) : '';
-            const childrenExpr = nodeChildren.map((child) => this.generateCode(child)).join(' + ');
-            const content = [textExpr, childrenExpr].filter((s) => s).join(' + ');
-
-            if (selfClosing) {
-                return '`<' + tagName + attrStr + '>`';
-            } else {
-                if (content) {
-                    return '`<' + tagName + attrStr + '>\${' + content + '}</' + tagName + '>``';
-                } else {
-                    return '`<' + tagName + attrStr + '></' + tagName + '>``';
-                }
-            }
-
-        case 'Each':
-            const {iterator, collection, children} = node;
-            const body = children.map((child) => this.generateCode(child)).join(' + ') || '""';
-            return `(Array.isArray(${collection}) ? ${collection}.map(${iterator} => ${body}).join('') : '')`;
-
-        case 'If':
-            const {condition, thenBranch, elseBranch} = node;
-            const thenCode = thenBranch.map((child) => this.generateCode(child)).join(' + ') || '""';
-            const elseCode = elseBranch.map((child) => this.generateCode(child)).join(' + ') || '""';
-            return `(${condition} ? ${thenCode} : ${elseCode})`;
-
-        case 'MixinCall':
-            const {definition, args} = node;
-            const paramMap = {};
-            definition.params.forEach((param, idx) => {
-                paramMap[param] = args[idx] || '""';
-            });
-            const substitutedBody = this.substituteParamsInAST(definition.body, paramMap);
-            const bodyCode = substitutedBody.map((child) => this.generateCode(child)).join(' + ') || '""';
-            return bodyCode;
-
-        default:
-            return '""';
-        }
-    }
-
-    /**
-     * Substitutes parameters in AST nodes with actual values.
-     * @param {Array} nodes - Array of AST nodes
-     * @param {Object} paramMap - Parameter mapping object
-     * @returns {Array} New array of AST nodes with substituted parameters
-     */
-    substituteParamsInAST(nodes, paramMap) {
-        return nodes.map((node) => {
-            const newNode = {...node};
-            if (node.type === 'Element') {
-                const newAttrs = {};
-                for (const [key, val] of Object.entries(node.attrs)) {
-                    newAttrs[key] = this.substituteInString(val, paramMap);
-                }
-                newNode.attrs = newAttrs;
-                newNode.text = this.substituteInString(node.text, paramMap);
-                newNode.children = this.substituteParamsInAST(node.children, paramMap);
-            } else if (node.type === 'Each' || node.type === 'If') {
-                newNode.children = this.substituteParamsInAST(node.children || node.thenBranch || [], paramMap);
-                if (node.elseBranch) {
-                    newNode.elseBranch = this.substituteParamsInAST(node.elseBranch, paramMap);
-                }
-            }
-            return newNode;
-        });
-    }
-
-    /**
-     * Substitutes parameter placeholders in a string with actual values.
-     * @param {string} str - String with parameter placeholders
-     * @param {Object} paramMap - Parameter mapping object
-     * @returns {string} String with substituted parameters
-     */
-    substituteInString(str, paramMap) {
-        if (!str) {
-            return str;
-        }
-        let result = str;
-        for (const [param, replacement] of Object.entries(paramMap)) {
-            const regex = new RegExp(`{{\\s*${param}\\s*}}`, 'g');
-            result = result.replace(regex, replacement);
-        }
-        return result;
-    }
-
-    /**
-     * Converts a string with interpolation expressions to executable JavaScript code.
-     * @param {string} str - String with interpolation expressions
-     * @param {boolean} inAttr - Whether the string is inside an attribute
-     * @returns {string} JavaScript code expression
-     */
-    interpolateToExpr(str, inAttr = false) {
-        if (!str || !/{{.*?}}/.test(str)) {
-            if (inAttr) {
-                return JSON.stringify(str);
-            } else {
-                return `escape(${JSON.stringify(str)})`;
-            }
-        }
-
-        str = str.replace(/`/g, '\\`').replace(/\$/g, '\\$');
-        const parts = [];
-        let lastIndex = 0;
-        str.replace(/{{\s*([^}]+?)\s*}}/g, (match, expr, offset) => {
-            if (offset > lastIndex) {
-                const literal = str.slice(lastIndex, offset);
-                if (inAttr) {
-                    parts.push(JSON.stringify(literal));
-                } else {
-                    parts.push(`escape(${JSON.stringify(literal)})`;
-                }
-            }
-            expr = expr.trim();
-            if (inAttr) {
-                parts.push(expr);
-            } else {
-                parts.push(`escape(${expr})`);
-            }
-            lastIndex = offset + match.length;
-        });
-
-        if (lastIndex < str.length) {
-            const literal = str.slice(lastIndex);
-            if (inAttr) {
-                parts.push(JSON.stringify(literal));
-            } else {
-                parts.push(`escape(${JSON.stringify(literal)})`;
-            }
-        }
-
-        return parts.join(' + ') || '""';
-    }
-}
-
-export default Template;

package/src/app/viewPort/Permalink.d2

@@ -1,27 +0,0 @@
-Router{
-    assignUrl
-    urlAction
-}
-OCP{
-    label: openComponentPlugin
-}
-
-RegisterComponent{
-    RouteUnit{
-        shape: class
-        action: string
-        componentType: string
-        componentId: string
-        parameters: object
-        shortUrl: string
-        id: string
-    }
-}
-
-OCP ->  RegisterComponent
-Menu -> RegisterComponent
-
-RegisterComponent -> OpenComponent
-RegisterComponent -> Router.assignUrl
-OpenComponent -> CenterView.setActiveComponent
-Router.urlAction -> RegisterComponent

package/src/app/viewPort/Router.d2

@@ -1,23 +0,0 @@
-changeUrl->Router.routes./\#r/ReportId{label: загрузить репорт в dev-режиме}
-changeUrl->Router.routes./\#p/CustomPanelId :загрузить кастомную панель в dev-режиме
-changeUrl->Router.routes./\#UiElementCd :начитать uiElementCd для загрузки компонента пункта меню
-
-Router: {
-	routes: {
-		/\#r/ReportId
-		/\#p/CustomPanelId
-		/\#UiElementCd
-	}
-	routes./\#r/ReportId -> ReportPanel_create
-	routes./\#p/CustomPanelId -> loadUlElement(xtype=UiCustomPanel): async load
-	loadUlElement(xtype=UiCustomPanel) -> UiCustomPanel_instancing
-	routes./\#UiElementCd -> loadUlElement
-	loadUlElement -> 'xtype=ReportPanel'
-	loadUlElement -> 'xtype=UiCustomPanel' -> loadUlElement(xtype=UiCustomPanel)
-}
-
-Router.loadUlElement.'xtype=ReportPanel' -> ComponentFactory.createRootNavComponent
-
-ComponentFactory: {
-	createRootNavComponent
-}