@solidxai/core-ui 0.0.1

package/dist/components/core/common/SolidViewLayoutManager.ts

@@ -0,0 +1,421 @@
+import { ERROR_MESSAGES } from "../../../constants/error-messages";
+import { LayoutAttribute, LayoutNode } from "../../../types/solid-core";
+
+/**
+ * SolidViewLayoutManager
+ *
+ * Central manager for mutating Solid View layout trees.
+ * Provides low-level tree operations and domain-specific helpers
+ * for view attributes, form buttons, and row buttons.
+ */
+export class SolidViewLayoutManager {
+    /** Internal mutable layout copy */
+    private layout: LayoutNode;
+
+    /**
+     * Creates a new layout manager instance.
+     * A deep copy of the provided layout is created to avoid side effects.
+     *
+     * @param layout - Original layout definition
+     */
+    constructor(layout: LayoutNode) {
+        // Create a deep copy to prevent modifying the original object
+        this.layout = structuredClone ? structuredClone(layout) : JSON.parse(JSON.stringify(layout));
+    }
+
+    /**
+     * Recursively finds a layout node by its `attrs.name`.
+     * Searches children and formButtons.
+     *
+     * @param node - Node to start searching from
+     * @param name - Name of the node to find
+     * @returns The matching LayoutNode or null
+     */
+    private findNode(node: LayoutNode, name: string): LayoutNode | null {
+        if (node.attrs.name === name) {
+            return node;
+        }
+
+        if (node.children) {
+            for (let child of node.children) {
+                const found = this.findNode(child, name);
+                if (found) return found;
+            }
+        }
+
+        // search in formButtons
+        if (node.attrs?.formButtons) {
+            for (const btn of node.attrs.formButtons) {
+                const found = this.findNode(btn, name);
+                if (found) return found;
+            }
+        }
+
+        return null;
+    }
+
+    private findNodes(node: LayoutNode, name: string): LayoutNode[] {
+        const nodes: LayoutNode[] = [];
+        if (node.attrs.name === name) {
+            nodes.push(node);
+        }
+        if (node.children) {
+            for (let child of node.children) {
+                nodes.push(...this.findNodes(child, name));
+            }
+        }
+        if (node.attrs?.formButtons) {
+            for (const btn of node.attrs.formButtons) {
+                nodes.push(...this.findNodes(btn, name));
+            }
+        }
+        return nodes;
+    }
+
+    /**
+     * Recursively removes a node from the layout tree.
+     *
+     * @param parent - Parent node to search within
+     * @param name - Name of the node to remove
+     * @returns true if the node was removed
+     */
+    private removeNodeRecursive(parent: LayoutNode, name: string): boolean {
+        if (!parent.children) return false;
+
+        const index = parent.children.findIndex((child) => child.attrs.name === name);
+        if (index !== -1) {
+            parent.children.splice(index, 1); // Remove the node
+            return true;
+        }
+
+        return parent.children.some((child) => this.removeNodeRecursive(child, name));
+    }
+
+
+    /**
+      * Returns the managed layout instance.
+      *
+      * @returns Current layout tree
+      */
+    getLayout(): LayoutNode {
+        // return structuredClone ? structuredClone(this.layout) : JSON.parse(JSON.stringify(this.layout));
+        return this.layout;
+    }
+
+    /**
+     * Updates attributes of a specific node.
+     * This method adds or overrides attributes.
+     *
+     * @param name - Node name
+     * @param newAttributes - Attributes to merge
+     * @returns true if node was found and updated
+     */
+    updateNodeAttributes(name: string, newAttributes: Partial<LayoutAttribute>): boolean {
+        const node = this.findNode(this.layout, name);
+        if (node) {
+            node.attrs = { ...node.attrs, ...newAttributes };
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Adds a child node to a parent node.
+     *
+     * @param parentName - Name of the parent node
+     * @param newNode - Child layout node to add
+     * @param addChildrenToAll - If true, adds the child node to all nodes with the given parent name
+     * @returns true if parent exists and child was added
+     */
+    addChildNode(parentName: string, newNode: LayoutNode, addChildrenToAll: boolean = false): boolean {
+        console.log(`timepass....`);
+        
+        if (addChildrenToAll) {
+            const parentNodes = this.findNodes(this.layout, parentName);
+            parentNodes.forEach((node) => {
+                if (!node.children) {
+                    node.children = [];
+                }
+                node.children.push(newNode);
+            });
+            return true;
+        }
+        else {
+            const parentNode = this.findNode(this.layout, parentName);
+            if (parentNode) {
+                if (!parentNode.children) {
+                    parentNode.children = [];
+                }
+                parentNode.children.push(newNode);
+                return true;
+            }
+            return false;
+        }
+    }
+
+
+    /**
+     * Removes a node and its subtree.
+     * Root node removal is prevented.
+     *
+     * @param name - Name of the node to remove
+     * @returns true if node was removed
+     */
+    removeNode(name: string): boolean {
+        if (this.layout.attrs.name === name) {
+            console.warn(ERROR_MESSAGES.REMOVE_ROOT_NODE);
+            return false;
+        }
+
+        return this.removeNodeRecursive(this.layout, name);
+    }
+
+    /**
+     * Traverses the entire layout tree and executes a callback for each node.
+     *
+     * @param callback - Function executed for each node
+     * @param node - Starting node (defaults to root)
+     */
+    traverse(callback: (node: LayoutNode) => void, node: LayoutNode = this.layout) {
+        callback(node);
+        if (node.children) {
+            node.children.forEach((child) => this.traverse(callback, child));
+        }
+    }
+
+
+
+    /**
+     * Adds or updates view-level attributes.
+     * Existing attributes are updated, missing attributes are added.
+     *
+     * @param attrs - Attributes to set on the view
+     * @returns true if at least one attribute was applied
+     */
+    setViewAttributes(attrs: Partial<LayoutAttribute>): boolean {
+        const viewNode = this.findNode(this.layout, this.layout.attrs.name);
+        if (!viewNode) return false;
+
+        let changed = false;
+
+        for (const key of Object.keys(attrs) as (keyof LayoutAttribute)[]) {
+            const newValue = attrs[key];
+
+            if (viewNode.attrs[key] !== newValue) {
+                viewNode.attrs[key] = newValue;
+                changed = true;
+            }
+        }
+
+        return changed;
+    }
+
+
+
+    /**
+     * Adds view-level attributes only if they do not already exist.
+     *
+     * @param attrs - Attributes to add
+     * @returns true if at least one attribute was added
+     */
+    addViewAttributes(attrs: Partial<LayoutAttribute>): boolean {
+        const viewNode = this.findNode(this.layout, this.layout.attrs.name);
+        if (!viewNode) return false;
+
+        let added = false;
+
+        for (const key in attrs) {
+            if (!(key in viewNode.attrs)) {
+                // @ts-ignore – layout attributes are dynamic
+                viewNode.attrs[key] = attrs[key];
+                added = true;
+            }
+        }
+
+        return added;
+    }
+
+    /**
+     * Updates existing view-level attributes.
+     * Attributes that do not exist are ignored.
+     *
+     * @param attrs - Attributes to update
+     * @returns true if at least one attribute was updated
+     */
+    updateViewAttributes(attrs: Partial<LayoutAttribute>): boolean {
+        const viewNode = this.findNode(this.layout, this.layout.attrs.name);
+        if (!viewNode) return false;
+
+        let updated = false;
+
+        for (const key in attrs) {
+            if (key in viewNode.attrs) {
+                // @ts-ignore
+                viewNode.attrs[key] = attrs[key];
+                updated = true;
+            }
+        }
+
+        return updated;
+    }
+
+
+    /**
+     * Removes specific view-level attributes.
+     *
+     * @param keys - Attribute keys to remove
+     * @returns true if at least one attribute was removed
+     */
+    removeViewAttributes(keys: (keyof LayoutAttribute)[]): boolean {
+        const viewNode = this.findNode(this.layout, this.layout.attrs.name);
+        if (!viewNode) return false;
+
+        let removed = false;
+
+        for (const key of keys) {
+            if (key in viewNode.attrs) {
+                // @ts-ignore
+                delete viewNode.attrs[key];
+                removed = true;
+            }
+        }
+
+        return removed;
+    }
+
+    /**
+     * Adds a new form-level button.
+     *
+     * @param button - Button layout node
+     */
+    addFormButton(button: LayoutNode): void {
+        this.layout.attrs.formButtons ??= [];
+        this.layout.attrs.formButtons.push(button);
+    }
+
+    /**
+     * Updates a form button identified by its action.
+     *
+     * @param action - Button action identifier
+     * @param attrs - Attributes to update
+     * @returns true if button was found and updated
+     */
+    updateFormButtonByAction(
+        action: string,
+        attrs: Partial<LayoutAttribute>
+    ): boolean {
+        const button = this.layout.attrs.formButtons?.find(
+            (b: any) => b.attrs.action === action
+        );
+
+        if (!button) return false;
+
+        button.attrs = { ...button.attrs, ...attrs };
+        return true;
+    }
+
+    /**
+     * Removes a form button by its action.
+     *
+     * @param action - Button action identifier
+     * @returns true if button was removed
+     */
+    removeFormButtonByAction(action: string): boolean {
+        if (!this.layout.attrs.formButtons) return false;
+
+        const initialLength = this.layout.attrs.formButtons.length;
+
+        this.layout.attrs.formButtons = this.layout.attrs.formButtons.filter(
+            (b: any) => b.attrs.action !== action
+        );
+
+        return this.layout.attrs.formButtons.length !== initialLength;
+    }
+
+    /**
+     * Disables a form-level button.
+     *
+     * @param action - Button action identifier
+     * @returns true if button was disabled
+     */
+    disableFormButton(action: string): boolean {
+        return this.updateFormButtonByAction(action, { disabled: true });
+    }
+
+
+    /**
+     * Hides a form-level button.
+     *
+     * @param action - Button action identifier
+     * @returns true if button was hidden
+     */
+    hideFormButton(action: string): boolean {
+        return this.updateFormButtonByAction(action, { visible: false });
+    }
+
+
+    /**
+     * Adds a row-level button to a field.
+     *
+     * @param fieldName - Target field name
+     * @param button - Button definition
+     * @returns true if field exists and button was added
+     */
+    addRowButtonToField(fieldName: string, button: LayoutNode): boolean {
+        const fieldNode = this.findNode(this.layout, fieldName);
+        if (!fieldNode) return false;
+
+        fieldNode.attrs.rowButtons ??= [];
+        fieldNode.attrs.rowButtons.push(button);
+        return true;
+    }
+
+    /**
+     * Updates a row-level button for a field.
+     *
+     * @param fieldName - Field name
+     * @param action - Button action identifier
+     * @param attrs - Attributes to update
+     * @returns true if button was updated
+     */
+    updateRowButtonByAction(
+        fieldName: string,
+        action: string,
+        attrs: Partial<LayoutAttribute>
+    ): boolean {
+        const fieldNode = this.findNode(this.layout, fieldName);
+        if (!fieldNode?.attrs?.rowButtons) return false;
+
+        const button = fieldNode.attrs.rowButtons.find(
+            (b: any) => b.action === action
+        );
+
+        if (!button) return false;
+
+        Object.assign(button, attrs);
+        return true;
+    }
+
+
+    /**
+     * Removes a row-level button from a field.
+     *
+     * @param fieldName - Field name
+     * @param action - Button action identifier
+     * @returns true if button was removed
+     */
+    removeRowButtonByAction(fieldName: string, action: string): boolean {
+        const fieldNode = this.findNode(this.layout, fieldName);
+        if (!fieldNode?.attrs?.rowButtons) return false;
+
+        const initialLength = fieldNode.attrs.rowButtons.length;
+
+        fieldNode.attrs.rowButtons = fieldNode.attrs.rowButtons.filter(
+            (b: any) => b.action !== action
+        );
+
+        return fieldNode.attrs.rowButtons.length !== initialLength;
+    }
+
+
+}

package/dist/components/core/common/SolidXAiIframe.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface SolidXAiIframeProps {
+    url: string;
+}
+export declare const SolidXAiIframe: React.FC<SolidXAiIframeProps>;
+export {};
+//# sourceMappingURL=SolidXAiIframe.d.ts.map

package/dist/components/core/common/SolidXAiIframe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolidXAiIframe.d.ts","sourceRoot":"","sources":["../../../../src/components/core/common/SolidXAiIframe.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAE3D,UAAU,mBAAmB;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAsExD,CAAC"}

package/dist/components/core/common/SolidXAiIframe.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+export var SolidXAiIframe = function (_a) {
+    var url = _a.url;
+    var _b = useState(null), reachable = _b[0], setReachable = _b[1];
+    useEffect(function () {
+        var handler = function (event) {
+            var _a;
+            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.action) === "REFRESH_PARENT") {
+                window.location.reload();
+            }
+        };
+        window.addEventListener("message", handler);
+        return function () { return window.removeEventListener("message", handler); };
+    }, []);
+    useEffect(function () {
+        var checkServer = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fetch(url, { method: "HEAD" })];
+                    case 1:
+                        res = _a.sent();
+                        if (res.ok) {
+                            setReachable(true);
+                        }
+                        else {
+                            setReachable(false);
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_1 = _a.sent();
+                        setReachable(false);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); };
+        checkServer();
+    }, [url]);
+    // Loading state
+    if (reachable === null) {
+        return (_jsx("div", { className: "flex items-center justify-center h-full text-gray-600", children: "Checking SolidX AI server..." }));
+    }
+    // Error state
+    if (reachable === false) {
+        return (_jsx("div", { className: "flex  items-center justify-center align-items-center h-full text-center p-4 overflow-x-auto\t", children: _jsxs("h3", { children: ["Mcp Server not reachable. ", _jsx("br", {}), _jsx("span", { className: "opacity-60 mt-2", children: _jsx("strong", { children: url }) })] }) }));
+    }
+    // SUCCESS → load iframe
+    return (_jsx("iframe", { src: url, style: {
+            width: "100%",
+            height: "100%",
+            border: "none",
+        }, allow: "clipboard-write; clipboard-read", title: "SolidX AI JSON Viewer" }));
+};
+//# sourceMappingURL=SolidXAiIframe.js.map

package/dist/components/core/common/SolidXAiIframe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolidXAiIframe.js","sourceRoot":"","sources":["../../../../src/components/core/common/SolidXAiIframe.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAc,EAAE,SAAS,EAAU,QAAQ,EAAE,MAAM,OAAO,CAAC;AAM3D,MAAM,CAAC,IAAM,cAAc,GAAkC,UAAC,EAAO;QAAL,GAAG,SAAA;IAC3D,IAAA,KAA4B,QAAQ,CAAiB,IAAI,CAAC,EAAzD,SAAS,QAAA,EAAE,YAAY,QAAkC,CAAC;IAGjE,SAAS,CAAC;QACV,IAAM,OAAO,GAAG,UAAC,KAAS;;YACxB,IAAI,CAAA,MAAA,KAAK,CAAC,IAAI,0CAAE,MAAM,MAAK,gBAAgB,EAAE;gBAC3C,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;aAC1B;QACH,CAAC,CAAC;QAEF,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC5C,OAAO,cAAM,OAAA,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,CAAC,EAA9C,CAA8C,CAAC;IAC9D,CAAC,EAAE,EAAE,CAAC,CAAC;IAIL,SAAS,CAAC;QACR,IAAM,WAAW,GAAG;;;;;;wBAGJ,qBAAM,KAAK,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAA;;wBAA1C,GAAG,GAAG,SAAoC;wBAEhD,IAAI,GAAG,CAAC,EAAE,EAAE;4BACV,YAAY,CAAC,IAAI,CAAC,CAAC;yBACpB;6BAAM;4BACL,YAAY,CAAC,KAAK,CAAC,CAAC;yBACrB;;;;wBAED,YAAY,CAAC,KAAK,CAAC,CAAC;;;;;aAEvB,CAAC;QAEF,WAAW,EAAE,CAAC;IAChB,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAEV,gBAAgB;IAChB,IAAI,SAAS,KAAK,IAAI,EAAE;QACtB,OAAO,CACL,cAAK,SAAS,EAAC,uDAAuD,6CAEhE,CACP,CAAC;KACH;IAED,cAAc;IACd,IAAI,SAAS,KAAK,KAAK,EAAE;QACvB,OAAO,CACL,cAAK,SAAS,EAAC,+FAA8F,YAC3G,uDAA8B,cAAS,EACrC,eAAM,SAAS,EAAC,iBAAiB,YAC/B,2BAAS,GAAG,GAAU,GACjB,IACJ,GACD,CACP,CAAC;KACH;IACD,wBAAwB;IACxB,OAAO,CACL,iBACE,GAAG,EAAE,GAAG,EACR,KAAK,EAAE;YACL,KAAK,EAAE,MAAM;YACb,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,MAAM;SACf,EACD,KAAK,EAAC,iCAAiC,EACvC,KAAK,EAAC,uBAAuB,GAC7B,CACH,CAAC;AACJ,CAAC,CAAC"}

package/dist/components/core/common/SolidXAiIframe.tsx

@@ -0,0 +1,77 @@
+import React, { useEffect, useRef, useState } from "react";
+
+interface SolidXAiIframeProps {
+  url: string;
+}
+
+export const SolidXAiIframe: React.FC<SolidXAiIframeProps> = ({ url }) => {
+  const [reachable, setReachable] = useState<boolean | null>(null);
+
+
+  useEffect(() => {
+  const handler = (event:any) => {
+    if (event.data?.action === "REFRESH_PARENT") {
+      window.location.reload();
+    }
+  };
+
+  window.addEventListener("message", handler);
+  return () => window.removeEventListener("message", handler);
+}, []);
+
+
+
+  useEffect(() => {
+    const checkServer = async () => {
+      try {
+        // Try to fetch the page HEAD (fast, no content)
+        const res = await fetch(url, { method: "HEAD" });
+
+        if (res.ok) {
+          setReachable(true);
+        } else {
+          setReachable(false);
+        }
+      } catch (err) {
+        setReachable(false);
+      }
+    };
+
+    checkServer();
+  }, [url]);
+
+  // Loading state
+  if (reachable === null) {
+    return (
+      <div className="flex items-center justify-center h-full text-gray-600">
+        Checking SolidX AI server...
+      </div>
+    );
+  }
+
+  // Error state
+  if (reachable === false) {
+    return (
+      <div className="flex  items-center justify-center align-items-center h-full text-center p-4 overflow-x-auto	">
+        <h3>Mcp Server not reachable. <br></br>
+          <span className="opacity-60 mt-2">
+            <strong>{url}</strong>
+          </span>
+        </h3>
+      </div>
+    );
+  }
+  // SUCCESS → load iframe
+  return (
+    <iframe
+      src={url}
+      style={{
+        width: "100%",
+        height: "100%",
+        border: "none",
+      }}
+      allow="clipboard-write; clipboard-read"
+      title="SolidX AI JSON Viewer"
+    />
+  );
+};

package/dist/components/core/dashboard/SolidDashboard.d.ts

@@ -0,0 +1,29 @@
+export declare enum DashboardVariableType {
+    DATE = "date",
+    SELECTION_STATIC = "selectionStatic",
+    SELECTION_DYNAMIC = "selectionDynamic"
+}
+declare enum SOURCE_TYPE {
+    SQL = "sql",
+    PROVIDER = "provider"
+}
+export interface DashboardVariableRecord {
+    id: number;
+    variableName: string;
+    variableType: DashboardVariableType;
+    selectionStaticValues?: string[];
+    selectionDynamicSourceType?: SOURCE_TYPE;
+    selectionDynamicProviderName?: string;
+    selectionDynamicSQL?: string;
+    isMultiSelect?: boolean;
+    defaultValue?: string;
+    defaultOperator?: string;
+}
+type SolidDashboardViewProps = {
+    moduleName: string;
+    dashboardId?: number;
+    dashboardName?: string;
+};
+declare const SolidDashboard: (params: SolidDashboardViewProps) => import("react/jsx-runtime").JSX.Element;
+export default SolidDashboard;
+//# sourceMappingURL=SolidDashboard.d.ts.map

package/dist/components/core/dashboard/SolidDashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolidDashboard.d.ts","sourceRoot":"","sources":["../../../../src/components/core/dashboard/SolidDashboard.tsx"],"names":[],"mappings":"AAoBA,oBAAY,qBAAqB;IAC/B,IAAI,SAAS;IACb,gBAAgB,oBAAoB;IACpC,iBAAiB,qBAAqB;CACvC;AAED,aAAK,WAAW;IACd,GAAG,QAAQ;IACX,QAAQ,aAAa;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,qBAAqB,CAAC;IACpC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,0BAA0B,CAAC,EAAE,WAAW,CAAC;IACzC,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAwED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,QAAA,MAAM,cAAc,WAAY,uBAAuB,4CAiNtD,CAAA;AAED,eAAe,cAAc,CAAC"}