igniteui-webcomponents-layouts 7.1.1-beta.2 → 7.1.1-beta.4

package/esm2022/lib/PropertyEditorPanelView_combined.js

@@ -0,0 +1,1105 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, runOn, delegateCombine, typeCast, delegateRemove, fromEn, enumGetBox, fromEnum, String_$type, EnumUtil } from "igniteui-webcomponents-core";
+import { RenderingContext } from "igniteui-webcomponents-core";
+import { FontInfo } from "igniteui-webcomponents-core";
+import { DOMExecutionContext } from "igniteui-webcomponents-core";
+import { CanvasViewRenderer } from "igniteui-webcomponents-core";
+import { NativeUIComponent } from "igniteui-webcomponents-core";
+import { Size } from "igniteui-webcomponents-core";
+import { NativeUI } from "igniteui-webcomponents-core";
+import { FontUtil } from "igniteui-webcomponents-core";
+import { SRProvider } from "igniteui-webcomponents-core";
+import { PropertyEditorPropertyDescriptionCollection } from "./PropertyEditorPropertyDescriptionCollection";
+import { PropertyEditorPanelUpdateMode_$type } from "./PropertyEditorPanelUpdateMode";
+import { List$1 } from "igniteui-webcomponents-core";
+import { ObservableCollection$1 } from "igniteui-webcomponents-core";
+import { PropertyEditorPanelColumnDefinition } from "./PropertyEditorPanelColumnDefinition";
+import { ComponentRenderer } from "igniteui-webcomponents-core";
+import { DeviceUtils } from "igniteui-webcomponents-core";
+import { Dictionary$2 } from "igniteui-webcomponents-core";
+import { PropertyEditorPropertyDescription } from "./PropertyEditorPropertyDescription";
+import { NativeUIInputsFactory } from "igniteui-webcomponents-core";
+import { NativeUILayoutFactory } from "./NativeUILayoutFactory";
+import { LocalDataSource } from "igniteui-webcomponents-core";
+import { PropertyEditorValueType_$type } from "./PropertyEditorValueType";
+import { PropertyEditorDataSource } from "./PropertyEditorDataSource";
+import { ToolActionCollection } from "./ToolActionCollection";
+import { PropertyEditorPanelComboBoxBridgeItem } from "./PropertyEditorPanelComboBoxBridgeItem";
+import { ToolActionNumberInput } from "./ToolActionNumberInput";
+import { ToolActionColorEditor } from "./ToolActionColorEditor";
+import { ToolActionTextInput } from "./ToolActionTextInput";
+import { ToolActionCheckbox } from "./ToolActionCheckbox";
+import { ToolActionCombo } from "./ToolActionCombo";
+import { ToolActionButton } from "./ToolActionButton";
+import { ToolActionSeparator } from "./ToolActionSeparator";
+import { ToolActionGroupHeader } from "./ToolActionGroupHeader";
+import { Guid } from "igniteui-webcomponents-core";
+import { CSSColorUtil } from "igniteui-webcomponents-core";
+import { LayoutSelectedItemsCollection } from "./LayoutSelectedItemsCollection";
+import { IAcceptsDataSeriesToDescriptionCustomizations_$type } from "igniteui-webcomponents-core";
+import { PropertyEditorTreeTransformer } from "./PropertyEditorTreeTransformer";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { stringReplace, stringContains } from "igniteui-webcomponents-core";
+import { stringSplit } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+class PropertyEditorPanelView extends Base {
+    static { this.$t = markType(PropertyEditorPanelView, 'PropertyEditorPanelView'); }
+    constructor() {
+        super();
+        this.n = null;
+        this.m = null;
+        this.a = null;
+        this.i = null;
+        this.l = null;
+        this.e = null;
+        this.k = null;
+        this.b = ((() => {
+            let $ret = new FontInfo();
+            $ret.q = "Verdana";
+            $ret.f = 13;
+            $ret.t = "Normal";
+            $ret.v = "Normal";
+            $ret.r = "Normal";
+            return $ret;
+        })());
+        this.aa = new Size();
+        this.c = null;
+        this._gridExternal = null;
+        this.f = false;
+        this.j = null;
+    }
+    p() {
+        return this.i;
+    }
+    v() {
+    }
+    t(a) {
+        if (a == null) {
+            this.i = null;
+            return;
+        }
+        this.a.k = new DOMExecutionContext(a);
+        this.i = a;
+        this.l = this.i.createElement("canvas");
+        this.e = new RenderingContext(new CanvasViewRenderer(), this.i.get2DCanvasContext(this.l));
+        this.k = this.i.createElement("div");
+        this.y();
+        NativeUIComponent.av(this.p(), 18, (b) => {
+            let c = b;
+            this.a.bw(c, this.n);
+            c.ao.setStyleProperty("width", "100%");
+            c.ao.setStyleProperty("height", "100%");
+            this.i.append(c.ao);
+        });
+        let b = Math.round(a.rootWrapper.width());
+        let c = Math.round(a.rootWrapper.height());
+        this.i.rootWrapper.setStyleProperty("position", "relative");
+    }
+    y() {
+    }
+    x() {
+        if (this.i != null) {
+        }
+    }
+    s() {
+        if (this.i == null) {
+            return;
+        }
+        let a = this.i.rootWrapper.width();
+        let b = this.i.rootWrapper.height();
+        this.aa = new Size(1, a, b);
+        if (this.a.l != null) {
+            this.a.cj();
+            this.a.l.b6(this.aa);
+        }
+    }
+    z() {
+        let a = this.i;
+        if (null == a) {
+            return;
+        }
+        let b = a.rootWrapper;
+        if (null != b) {
+            NativeUI.r(b, this.a.cr);
+            NativeUI.n(b, this.a.co);
+        }
+    }
+    d() {
+        return this.b;
+    }
+    u() {
+    }
+    w() {
+    }
+    r() {
+    }
+    g() {
+        return this.aa.width;
+    }
+    h(a) {
+        this.c = this.a.y();
+        return FontUtil.measureStringWidth(a, this.c, this.e);
+    }
+    q(a, b) {
+        if (this.j == null) {
+            this.j = this.i.createElement("div");
+        }
+        b(this.j.getNativeElement());
+    }
+}
+export { PropertyEditorPanelView };
+/**
+ * @hidden
+ */
+class PropertyEditorPanel extends Base {
+    static { this.$t = markType(PropertyEditorPanel, 'PropertyEditorPanel', Base.$, [INotifyPropertyChanged_$type]); }
+    get aa() {
+        if (this.z == null) {
+            this.z = new SRProvider(this.p.i);
+            this.z.cb("Layouts");
+        }
+        return this.z;
+    }
+    constructor() {
+        super();
+        this.p = null;
+        this.l = null;
+        this.v = null;
+        this.ac = false;
+        this.ad = false;
+        this.z = null;
+        this.propertyChanged = null;
+        this.aj = false;
+        this.q = null;
+        this.r = new PropertyEditorPropertyDescriptionCollection();
+        this.aw = -1;
+        this.n = 0;
+        this.au = DeviceUtils.g(38);
+        this.w = null;
+        this.a1 = null;
+        this.d = null;
+        this.ar = null;
+        this.k = null;
+        this.ai = false;
+        this.aq = new Dictionary$2(String_$type, PropertyEditorPropertyDescription.$, 0);
+        this.at = null;
+        this.a5 = null;
+        this.ah = true;
+        this.ab = false;
+        this.g = null;
+        this.h = null;
+        this.e = null;
+        this.a0 = null;
+        this.a6 = null;
+        this.ae = false;
+        this.ag = false;
+        this.af = false;
+        this.cm = PropertyEditorPanel.cp;
+        this.cn = PropertyEditorPanel.cq;
+        this.ay = 0;
+        this.ax = -1;
+        this.m = null;
+        NativeUIInputsFactory.n();
+        NativeUILayoutFactory.g();
+        this.at = new ObservableCollection$1(PropertyEditorPanelColumnDefinition.$, 0);
+        let a = new PropertyEditorPanelView();
+        a.a = this;
+        this.p = a;
+        this.p.v();
+        let b = this.properties;
+        b.collectionChanged = delegateCombine(b.collectionChanged, runOn(this, this.ca));
+    }
+    ca(a, b) {
+        if (b.oldItems != null) {
+            for (let c of fromEn(b.oldItems)) {
+                if (typeCast(INotifyPropertyChanged_$type, c) !== null) {
+                    let d = c;
+                    d.propertyChanged = delegateRemove(d.propertyChanged, runOn(this, this.bx));
+                }
+            }
+        }
+        if (b.newItems != null) {
+            for (let e of fromEn(b.newItems)) {
+                if (typeCast(INotifyPropertyChanged_$type, e) !== null) {
+                    let f = e;
+                    f.propertyChanged = delegateCombine(f.propertyChanged, runOn(this, this.bx));
+                }
+            }
+        }
+        this.an();
+        if (this.properties.count > 0 && this.actualProperties != this.properties) {
+            this.actualProperties = this.properties;
+        }
+        if (this.d != null) {
+            this.d.notifyClearItems();
+        }
+        this.b5();
+    }
+    b5() {
+        if (!this.aj) {
+            if (this.l != null) {
+                this.cj();
+            }
+        }
+    }
+    bx(a, b) {
+        if (!this.aj) {
+            this.an();
+            if (this.l != null) {
+                this.cj();
+            }
+        }
+    }
+    notifySizeChanged() {
+        this.p.s();
+    }
+    bw(a, b) {
+        this.l = a;
+        if (null != this.l) {
+            this.l.bt = runOn(this, this.b9);
+            this.cl();
+            if (this.actualProperties != null) {
+                this.a1 = this.actualProperties;
+                let c = this.actualProperties;
+                c = this.actualProperties.toArray();
+                let d = new LocalDataSource();
+                d.dataSource = c;
+                this.d = d;
+                this.br();
+            }
+            if (this.actualProperties != null) {
+                this.cj();
+            }
+        }
+    }
+    b9(a, b) {
+        this.aj = true;
+        if (this.aq.containsKey(b.a.commandId)) {
+            let c = this.aq.item(b.a.commandId);
+            this.b3(c, b);
+        }
+        this.aj = false;
+    }
+    b3(a, b) {
+        switch (a.w) {
+            case 0: break;
+            case 19:
+            case 1:
+                this.ch(a, b);
+                this.b7(a);
+                break;
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 23:
+                this.ci(a, b);
+                this.b7(a);
+                break;
+            case 7:
+                this.ce(a, b);
+                this.b7(a);
+                break;
+            case 8:
+            case 9:
+            case 10:
+            case 16:
+            case 17:
+            case 18:
+            case 22: break;
+            case 15:
+                this.cg(a, b);
+                this.b7(a);
+                break;
+            case 20:
+                this.cf(a, b);
+                break;
+            default: return;
+        }
+    }
+    cf(a, b) {
+        a.a6();
+    }
+    cg(a, b) {
+        let c = b.a.argumentsList[0].value;
+        if (c != null && c.length > 0) {
+            let d = c[0];
+            a.ar = d;
+            a.aa = true;
+            a.a5();
+        }
+        else {
+            a.ar = null;
+            a.aa = true;
+            a.a5();
+        }
+    }
+    ce(a, b) {
+        let c = b.a.argumentsList[0].value;
+        a.ar = c;
+        a.aa = true;
+        a.a5();
+    }
+    ci(a, b) {
+        let c = b.a.argumentsList[0].value;
+        a.ar = c;
+        a.aa = true;
+        a.a5();
+    }
+    ch(a, b) {
+        let c = b.a.argumentsList[0].value;
+        a.ar = c;
+        a.aa = true;
+        a.a5();
+    }
+    cl() {
+        if (this.l != null) {
+            if (this.ak && this.am) {
+                this.l.bv = 2;
+            }
+            else if (this.ak) {
+                this.l.bv = 1;
+            }
+            else {
+                this.l.bv = 0;
+            }
+        }
+    }
+    destroy() {
+        this.provideContainer(null);
+    }
+    provideContainer(a) {
+        this.p.t(a);
+    }
+    b4(a) {
+    }
+    get actualProperties() {
+        return this.q;
+    }
+    set actualProperties(a) {
+        let b = this.q;
+        this.q = a;
+        if (b != this.q) {
+            this.b6("ActualProperties", b, this.q);
+        }
+    }
+    get properties() {
+        return this.r;
+    }
+    set properties(a) {
+        let b = this.r;
+        this.r = a;
+        if (b != this.r) {
+            this.b6("Properties", b, this.r);
+        }
+    }
+    get az() {
+        return this.aw;
+    }
+    set az(a) {
+        let b = this.aw;
+        this.aw = a;
+        if (b != this.aw) {
+            this.b6("RowHeight", b, this.aw);
+        }
+    }
+    get o() {
+        return this.n;
+    }
+    set o(a) {
+        let b = this.n;
+        this.n = a;
+        if (b != this.n) {
+            this.b6("UpdateMode", enumGetBox(PropertyEditorPanelUpdateMode_$type, b), enumGetBox(PropertyEditorPanelUpdateMode_$type, this.n));
+        }
+    }
+    get av() {
+        return this.au;
+    }
+    set av(a) {
+        this.au = a;
+    }
+    get x() {
+        return this.w;
+    }
+    set x(a) {
+        let b = this.w;
+        this.w = a;
+        if (b != this.w) {
+            this.b6("CellTextStyle", b, this.w);
+        }
+    }
+    y() {
+        if (this.x == null) {
+            return this.p.d();
+        }
+        return this.x;
+    }
+    b6(a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.cb(a, b, c);
+    }
+    cb(a, b, c) {
+        switch (a) {
+            case "DescriptionType":
+                if (this.be == null) {
+                    if (this.properties == null) {
+                        this.actualProperties = null;
+                    }
+                }
+                if (this.be != null) {
+                    if (this.m == null) {
+                        this.m = new PropertyEditorDataSource();
+                    }
+                    this.m.n = this.be;
+                }
+                if (this.properties == null || this.properties.count == 0) {
+                    if (this.m.h != null) {
+                        this.actualProperties = this.m.h;
+                    }
+                }
+                else {
+                    if (this.properties != null && this.properties.count > 0) {
+                        this.an();
+                    }
+                }
+                break;
+            case "ComponentRenderer":
+                if (b != null) {
+                    if (this.ab) {
+                        this.ab = false;
+                        b.removeTargetPropertyUpdatingListener(runOn(this, this.ap));
+                    }
+                }
+                if (b != c) {
+                    this.ah = true;
+                }
+                if (this.f == null) {
+                    this.i = this.j;
+                }
+                else {
+                    this.i = this.f.context;
+                }
+                break;
+            case "Target":
+                if (ComponentRenderer.defaultInstance != null && this.f == null) {
+                    this.f = ComponentRenderer.defaultInstance;
+                }
+                break;
+            case "DescriptionContext":
+                if (this.f == null) {
+                    this.i = c;
+                }
+                break;
+            case "ActualContext":
+                if (this.i == null) {
+                    if (this.properties == null) {
+                        this.actualProperties = null;
+                    }
+                }
+                if (this.i != null) {
+                    if (this.m == null) {
+                        this.m = new PropertyEditorDataSource();
+                    }
+                    this.m.b = this.i;
+                }
+                if (this.properties == null || this.properties.count == 0) {
+                    if (this.m.h != null) {
+                        this.actualProperties = this.m.h;
+                    }
+                }
+                else {
+                    if (this.properties != null && this.properties.count > 0) {
+                        this.an();
+                    }
+                }
+                break;
+            case "Properties":
+                this.actualProperties = this.properties;
+                break;
+            case "IsWrappingEnabled":
+                this.cl();
+                this.cj();
+                break;
+            case "IsHorizontal":
+                this.cl();
+                break;
+            case "ActualProperties":
+                if (this.l != null) {
+                    let d = this.a1 != this.actualProperties;
+                    this.a1 = this.actualProperties;
+                    let e = this.actualProperties;
+                    e = this.actualProperties.toArray();
+                    let f = new LocalDataSource();
+                    f.dataSource = e;
+                    this.d = f;
+                    this.br();
+                    if (this.d != null) {
+                        let g = this.d;
+                        g.schemaChanged = delegateCombine(g.schemaChanged, runOn(this, this.b8));
+                    }
+                    if (d) {
+                        this.cj();
+                    }
+                }
+                break;
+            case "RowHeight":
+                if (this.l != null) {
+                    this.av = this.az;
+                }
+                break;
+            case "CellTextStyle":
+                this.cd();
+                break;
+            case "BackgroundColor":
+            case "TextColor":
+                this.cd();
+                break;
+        }
+    }
+    an() {
+        let a = this.aj;
+        this.aj = true;
+        let b = false;
+        for (let c of fromEnum(this.properties)) {
+            let d = c.a3;
+            if (this.m != null) {
+                let e = this.m.e(d, false);
+                if (e != null) {
+                    if (c.z(e)) {
+                        b = true;
+                    }
+                }
+            }
+        }
+        if (b) {
+            this.cj();
+        }
+        else if (this.l != null) {
+            this.cd();
+        }
+        this.aj = a;
+        return b;
+    }
+    cd() {
+        if (!this.ai && this.k != null) {
+            this.ai = true;
+            this.k.enqueueAction(runOn(this, this.bt));
+        }
+    }
+    bt() {
+        this.aq.clear();
+        this.ai = false;
+        if (this.ar == null) {
+            this.ar = new List$1(List$1.$.specialize(NativeUIComponent.$), 0);
+        }
+        if (this.d == null) {
+            return;
+        }
+        let a = this.d.actualCount;
+        let b = new ToolActionCollection();
+        for (let c = 0; c < a; c++) {
+            let d = this.d.getItemAtIndex(c);
+            let e = this.u(d);
+            if (e == null) {
+                continue;
+            }
+            b.add(e);
+        }
+        this.ck(b);
+    }
+    ck(a) {
+        this.l.bu = a;
+    }
+    a4(a) {
+        if (a == null) {
+            return null;
+        }
+        let b = new List$1(PropertyEditorPanelComboBoxBridgeItem.$, 0);
+        for (let c = 0; c < a.length; c++) {
+            b.add(((() => {
+                let $ret = new PropertyEditorPanelComboBoxBridgeItem();
+                $ret.label = a[c];
+                return $ret;
+            })()));
+        }
+        return b;
+    }
+    c(a) {
+        return a.c;
+    }
+    bm(a) {
+        if (a.az != null) {
+            return a.az;
+        }
+        if (a.a3 != null) {
+            return a.a3;
+        }
+        return a.az;
+    }
+    u(a) {
+        let b = a;
+        let c = null;
+        switch (b.w) {
+            case 0: break;
+            case 19:
+            case 1:
+                let d = new ToolActionNumberInput();
+                d.hz = b.ar != null ? b.ar : NaN;
+                d.fb = this.bm(b);
+                c = d;
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                break;
+            case 4:
+            case 5:
+                let e = new ToolActionColorEditor();
+                e.h3 = CSSColorUtil.g(b.ar);
+                e.fb = this.bm(b);
+                c = e;
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                break;
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 2:
+            case 3:
+            case 6:
+            case 23:
+                let f = new ToolActionTextInput();
+                f.hz = b.ar;
+                f.fb = this.bm(b);
+                c = f;
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                break;
+            case 7:
+                let g = new ToolActionCheckbox();
+                g.hy = b.ar != null ? b.ar : false;
+                g.fb = this.bm(b);
+                c = g;
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                break;
+            case 8:
+            case 9:
+            case 10:
+            case 16:
+            case 17:
+            case 18:
+            case 22: return null;
+            case 15:
+                let h = new ToolActionCombo();
+                h.itemsSource = this.a4(this.c(b));
+                h.fb = this.bm(b);
+                c = h;
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                if (b.ar != null) {
+                    h.hx = new LayoutSelectedItemsCollection();
+                    h.hx.add1(b.ar);
+                }
+                break;
+            case 20:
+                let i = new ToolActionButton();
+                i.fb = this.bm(b);
+                if (b.ar != null && typeof b.ar === 'string') {
+                    i.fb = b.ar;
+                }
+                c = i;
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                break;
+            case 24:
+                let j = new ToolActionSeparator();
+                j.hz = 5;
+                c = j;
+                break;
+            case 25:
+                let k = new ToolActionGroupHeader();
+                c = k;
+                c.fb = this.bm(b);
+                if (b.a4 != null) {
+                    c.e5 = b.a4;
+                }
+                break;
+            default: return null;
+        }
+        let l = this.bl(b.a3);
+        if (l == null) {
+            l = b.a0;
+        }
+        if (l == null) {
+            let m = this.aj;
+            this.aj = true;
+            b.a0 = Guid.newGuid().toString();
+            l = b.a0;
+            this.aj = m;
+        }
+        if (c == null) {
+            return null;
+        }
+        c.er = this.be + "_" + l;
+        this.aq.item(c.er, b);
+        return c;
+    }
+    bl(a) {
+        if (a == null) {
+            return null;
+        }
+        return stringReplace(stringReplace(stringReplace(stringReplace(stringReplace(a, ".", "__dot__"), "[", "__ob__"), "]", "__cb__"), " ", "__sp__"), "*", "__star__");
+    }
+    b8(a, b) {
+        this.ad = true;
+        this.br();
+        this.ad = false;
+    }
+    cj() {
+        if (this.l == null) {
+            return;
+        }
+        this.cd();
+        this.p.r();
+    }
+    cs() {
+        if (this.l != null) {
+            return this.l.bg(new Size(1, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY));
+        }
+        else {
+            return new Size(1, 0, 0);
+        }
+    }
+    a2(a) {
+        return a.i;
+    }
+    b7(a) {
+        if (this.a3 != null && this.f != null) {
+            if (this.o == 2) {
+                let b = this.a();
+                let c = this.a2(this.a3);
+                if (typeCast(IAcceptsDataSeriesToDescriptionCustomizations_$type, c) !== null) {
+                    c.onCustomizationsChanged(b);
+                }
+            }
+            else {
+                if (this.ah) {
+                    this.ab = true;
+                    this.ah = false;
+                    this.f.addTargetPropertyUpdatingListener(runOn(this, this.ap));
+                }
+                let d = this.a5 == null;
+                this.a5 = this.bg();
+                if (d) {
+                    this.p.q(this.a3, (e) => this.f.loadJsonOverlay(this.a5, (f) => e, (f) => this.a3));
+                }
+                else {
+                    this.p.q(this.a3, (e) => this.f.loadJsonDelta(this.a5, (f) => e, false));
+                }
+            }
+        }
+    }
+    a() {
+        let a = this.actualProperties;
+        let b = new PropertyEditorTreeTransformer(this.i, this.be, true);
+        this.bu(a, "", b, this.be);
+        return b.a();
+    }
+    static b(a, b, c) {
+        let d = new PropertyEditorTreeTransformer(a, b, true);
+        PropertyEditorPanel.bv(c, "", d, b);
+        return d.a();
+    }
+    ap(a, b, c) {
+        let d = this.actualProperties;
+        for (let e = 0; e < d.count; e++) {
+            let f = d._inner[e].a3;
+            if (this.ao(f, a)) {
+                d._inner[e].a9(a, b, c);
+            }
+        }
+        if (this.al) {
+            return true;
+        }
+        return false;
+    }
+    ao(a, b) {
+        if (a == null && b == null) {
+            return true;
+        }
+        if (a == null) {
+            return false;
+        }
+        if (b == null) {
+            return false;
+        }
+        let c = stringSplit(a, ['.', '['], 0);
+        let d = stringSplit(b, ['.', '['], 0);
+        if (c.length != d.length) {
+            return false;
+        }
+        for (let e = 0; e < c.length; e++) {
+            let f = c[e];
+            let g = d[e];
+            if (stringContains(f, "]")) {
+                if (!stringContains(g, "]")) {
+                    return false;
+                }
+                g = stringReplace(g, "]", "");
+                let h = this.as(f);
+                if (!h.contains(g)) {
+                    return false;
+                }
+            }
+            else {
+                if (!Base.equalsStatic(f, g)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    as(a) {
+        let b = new List$1(String_$type, 0);
+        if (stringContains(a, "]")) {
+            a = stringReplace(a, "]", "");
+            let c = a.split(',');
+            for (let d = 0; d < c.length; d++) {
+                let e = c[d];
+                if (stringContains(e, "as")) {
+                    let f = e.indexOf("as");
+                    let g = e.substr(0, f).trim();
+                    b.add(g);
+                }
+            }
+            return b;
+        }
+        b.add(a);
+        return b;
+    }
+    bg() {
+        if (this.actualProperties == null) {
+            return null;
+        }
+        let a = this.actualProperties;
+        let b = new PropertyEditorTreeTransformer(this.i, this.be, false);
+        this.bu(a, "", b, this.be);
+        return b.j();
+    }
+    bu(a, b, c, d) {
+        for (let e = 0; e < a.count; e++) {
+            let f = a._inner[e];
+            let g = f.ac;
+            let h = f.w;
+            let i = f.m;
+            let j = f.i;
+            let k = f.ar;
+            if (g) {
+                h = f.v;
+                i = f.l;
+                j = f.h;
+                k = f.ap;
+            }
+            if (h == 20 || h == 25 || h == 24) {
+                continue;
+            }
+            if (i != null && i.count > 0) {
+                for (let l = 0; l < i.count; l++) {
+                    let m = i._inner[l];
+                    let n = b + f.a3 + "[" + l + "]";
+                    this.bu(m.a, n, c, m.b);
+                }
+            }
+            else if (j != null) {
+                let o = b + f.a3;
+                this.bu(j.a, o, c, j.b);
+            }
+            else {
+                if (h == 15 && k == null) {
+                    continue;
+                }
+                c.k(b + f.a3, k, d);
+            }
+        }
+    }
+    static bv(a, b, c, d) {
+        for (let e = 0; e < a.length; e++) {
+            let f = a[e];
+            let g = f.useCoercedValue;
+            let h = f.valueType;
+            let i = f.complexValues;
+            let j = f.complexValue;
+            let k = f.primitiveValue;
+            if (g) {
+                h = f.coercedValueType;
+                i = f.coercedComplexValues;
+                j = f.coercedComplexValue;
+                k = f.coercedPrimitiveValue;
+            }
+            let l = 0;
+            let m = EnumUtil.tryParse$1(PropertyEditorValueType_$type, h, true, l);
+            l = m.p2;
+            if (l == 20 || l == 25 || l == 24) {
+                continue;
+            }
+            if (i != null && i.length > 0) {
+                for (let n = 0; n < i.length; n++) {
+                    let o = i[n];
+                    let p = b + f.propertyPath + "[" + n + "]";
+                    PropertyEditorPanel.bv(o.properties, p, c, o.descriptionType);
+                }
+            }
+            else if (j != null) {
+                let q = b + f.propertyPath;
+                PropertyEditorPanel.bv(j.properties, q, c, j.descriptionType);
+            }
+            else {
+                c.k(b + f.propertyPath, k, d);
+            }
+        }
+    }
+    b1(a, b, c) {
+        if (this.l != null) {
+            this.cd();
+        }
+    }
+    by() {
+        if (this.l != null) {
+            this.cd();
+        }
+    }
+    bz(a, b) {
+        if (this.l != null) {
+            this.cd();
+        }
+        ;
+    }
+    b0(a, b) {
+        if (this.l != null) {
+            this.cd();
+        }
+        ;
+    }
+    get i() {
+        return this.g;
+    }
+    set i(a) {
+        let b = this.g;
+        this.g = a;
+        this.b6("ActualContext", b, this.g);
+    }
+    get j() {
+        return this.h;
+    }
+    set j(a) {
+        let b = this.h;
+        this.h = a;
+        this.b6("DescriptionContext", b, this.h);
+    }
+    get f() {
+        return this.e;
+    }
+    set f(a) {
+        let b = this.e;
+        this.e = a;
+        this.b6("ComponentRenderer", b, this.e);
+    }
+    get a3() {
+        return this.a0;
+    }
+    set a3(a) {
+        let b = this.a0;
+        this.a0 = a;
+        this.b6("Target", b, this.a0);
+    }
+    get be() {
+        return this.a6;
+    }
+    set be(a) {
+        let b = this.a6;
+        this.a6 = a;
+        this.b6("DescriptionType", b, this.a6);
+    }
+    get ak() {
+        return this.ae;
+    }
+    set ak(a) {
+        let b = this.ae;
+        this.ae = a;
+        this.b6("IsHorizontal", b, this.ae);
+    }
+    get am() {
+        return this.ag;
+    }
+    set am(a) {
+        let b = this.ag;
+        this.ag = a;
+        this.b6("IsWrappingEnabled", b, this.ag);
+    }
+    get al() {
+        return this.af;
+    }
+    set al(a) {
+        let b = this.af;
+        this.af = a;
+        this.b6("IsIndirectModeEnabled", b, this.af);
+    }
+    static { this.cp = BrushUtil.l(255, 248, 248, 248); }
+    get co() {
+        return this.cm;
+    }
+    set co(a) {
+        let b = this.cm;
+        this.cm = a;
+        if (b != this.cm) {
+            this.b6("BackgroundColor", b, a);
+        }
+    }
+    static { this.cq = BrushUtil.l(255, 24, 29, 31); }
+    get cr() {
+        return this.cn;
+    }
+    set cr(a) {
+        let b = this.cn;
+        this.cn = a;
+        if (b != this.cn) {
+            this.b6("TextColor", b, a);
+        }
+    }
+    br() {
+        let a = this.d;
+        if (null != a) {
+            if (null == a.actualSchema) {
+                this.ax = -1;
+                return;
+            }
+            let b = a.actualCount;
+            this.ax = b;
+        }
+        else {
+            this.ax = -1;
+        }
+    }
+}
+export { PropertyEditorPanel };