@node-projects/web-component-designer 0.0.142 → 0.0.143

package/dist/elements/services/propertiesService/services/CommonPropertiesService.js

@@ -1,7 +1,6 @@
-import { ValueType } from "../ValueType";
-import { BindingTarget } from "../../../item/BindingTarget";
 import { PropertyType } from "../PropertyType";
-export class CommonPropertiesService {
+import { AbstractPropertiesService } from "./AbstractPropertiesService";
+export class CommonPropertiesService extends AbstractPropertiesService {
     listNeedsRefresh(designItem) {
         return true;
     }
@@ -41,82 +40,4 @@ export class CommonPropertiesService {
     getProperties(designItem) {
         return this.commonProperties;
     }
-    setValue(designItems, property, value) {
-        for (let d of designItems) {
-            if (property.type == 'boolean' && !value) {
-                d.attributes.delete(property.name);
-                d.element.removeAttribute(property.name);
-            }
-            else if (property.type == 'boolean' && value) {
-                d.attributes.set(property.name, "");
-                d.element.setAttribute(property.name, "");
-            }
-            else {
-                d.attributes.set(property.name, value);
-                d.element.setAttribute(property.name, value);
-            }
-        }
-    }
-    getPropertyTarget(designItem, property) {
-        return BindingTarget.property;
-    }
-    clearValue(designItems, property) {
-        for (let d of designItems) {
-            d.attributes.delete(property.name);
-            d.element.removeAttribute(property.name);
-            d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
-            });
-        }
-    }
-    isSet(designItems, property) {
-        let all = true;
-        let some = false;
-        if (designItems != null && designItems.length !== 0) {
-            let attributeName = property.name;
-            designItems.forEach((x) => {
-                let has = x.attributes.has(attributeName);
-                all = all && has;
-                some = some || has;
-            });
-            //todo: optimize perf, do not call bindings service for each property. 
-            const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                return s.getBindings(designItems[0]);
-            });
-            if (bindings && bindings.find(x => x.target == BindingTarget.property && x.targetName == property.name))
-                return ValueType.bound;
-        }
-        else
-            return ValueType.none;
-        return all ? ValueType.all : some ? ValueType.some : ValueType.none;
-    }
-    getValue(designItems, property) {
-        if (designItems != null && designItems.length !== 0) {
-            let attributeName = property.name;
-            if (property.type == 'boolean')
-                return designItems[0].attributes.has(attributeName);
-            let lastValue = designItems[0].attributes.get(attributeName);
-            /*
-            for (const x of designItems) {
-              let value = x.attributes.get(attributeName);
-              if (value != lastValue) {
-                lastValue = null;
-                break;
-              }
-            }
-            */
-            return lastValue;
-        }
-        return null;
-    }
-    getBinding(designItems, property) {
-        //TODO: optimize perf, do not call bindings service for each property. 
-        const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-            return s.getBindings(designItems[0]);
-        });
-        return bindings.find(x => (x.target == BindingTarget.property || x.target == BindingTarget.attribute) && x.targetName == property.name);
-    }
-    getUnsetValue(designItems, property) {
-        return property.defaultValue;
-    }
 }

package/dist/elements/services/propertiesService/services/CssPropertiesService.d.ts

@@ -1,24 +1,15 @@
-import { IPropertiesService } from '../IPropertiesService';
 import { IProperty } from '../IProperty';
 import { IDesignItem } from '../../../item/IDesignItem';
-import { ValueType } from '../ValueType';
 import { BindingTarget } from '../../../item/BindingTarget.js';
-import { IBinding } from '../../../item/IBinding';
-export declare class CssPropertiesService implements IPropertiesService {
+import { CommonPropertiesService } from './CommonPropertiesService';
+export declare class CssPropertiesService extends CommonPropertiesService {
     listNeedsRefresh(designItem: IDesignItem): boolean;
     layout: IProperty[];
     grid: IProperty[];
     flex: IProperty[];
-    name: 'styles' | 'layout' | 'grid' | 'flex';
     constructor(name: 'styles' | 'layout' | 'grid' | 'flex');
     isHandledElement(designItem: IDesignItem): boolean;
     getProperty(designItem: IDesignItem, name: string): IProperty;
     getProperties(designItem: IDesignItem): IProperty[];
-    setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
     getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
-    clearValue(designItems: IDesignItem[], property: IProperty): void;
-    isSet(designItems: IDesignItem[], property: IProperty): ValueType;
-    getValue(designItems: IDesignItem[], property: IProperty): string;
-    getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
-    getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
 }

package/dist/elements/services/propertiesService/services/CssPropertiesService.js

@@ -1,8 +1,7 @@
-import { ValueType } from '../ValueType';
-import { NodeType } from '../../../item/NodeType';
 import { BindingTarget } from '../../../item/BindingTarget.js';
 import { PropertyType } from '../PropertyType';
-export class CssPropertiesService {
+import { CommonPropertiesService } from './CommonPropertiesService';
+export class CssPropertiesService extends CommonPropertiesService {
     listNeedsRefresh(designItem) {
         return this.name == 'styles' ? true : false;
     }
@@ -178,8 +177,8 @@ export class CssPropertiesService {
             propertyType: PropertyType.cssValue
         }
     ];
-    name;
     constructor(name) {
+        super();
         this.name = name;
     }
     isHandledElement(designItem) {
@@ -201,75 +200,7 @@ export class CssPropertiesService {
         }
         return this[this.name];
     }
-    setValue(designItems, property, value) {
-        const cg = designItems[0].openGroup("properties changed");
-        for (let d of designItems) {
-            d.styles.set(property.name, value);
-            d.element.style[property.name] = value;
-        }
-        cg.commit();
-    }
     getPropertyTarget(designItem, property) {
         return BindingTarget.css;
     }
-    clearValue(designItems, property) {
-        for (let d of designItems) {
-            d.styles.delete(property.name);
-            d.element.style[property.name] = '';
-            d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
-            });
-        }
-    }
-    isSet(designItems, property) {
-        let all = true;
-        let some = false;
-        if (designItems != null && designItems.length !== 0) {
-            designItems.forEach((x) => {
-                let has = x.styles.has(property.name);
-                all = all && has;
-                some = some || has;
-            });
-            //todo: optimize perf, do not call bindings service for each property. 
-            const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                return s.getBindings(designItems[0]);
-            });
-            if (bindings && bindings.find(x => x.target == BindingTarget.css && x.targetName == property.name))
-                return ValueType.bound;
-        }
-        else
-            return ValueType.none;
-        return all ? ValueType.all : some ? ValueType.some : ValueType.none;
-    }
-    getValue(designItems, property) {
-        if (designItems != null && designItems.length !== 0) {
-            let lastValue = designItems[0].styles.get(property.name);
-            for (const x of designItems) {
-                let value = x.styles.get(property.name);
-                if (value != lastValue) {
-                    lastValue = null;
-                    break;
-                }
-            }
-            return lastValue;
-        }
-        return null;
-    }
-    getBinding(designItems, property) {
-        //TODO: optimize perf, do not call bindings service for each property. 
-        const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-            return s.getBindings(designItems[0]);
-        });
-        return bindings.find(x => (x.target == BindingTarget.css) && x.targetName == property.name);
-    }
-    //todo: optimize perf, call window.getComputedStyle only once per item, and not per property
-    getUnsetValue(designItems, property) {
-        if (designItems != null && designItems.length !== 0) {
-            if (designItems[0].nodeType == NodeType.Element) {
-                let v = window.getComputedStyle(designItems[0].element)[property.name];
-                return v;
-            }
-        }
-        return null;
-    }
 }

package/dist/elements/services/propertiesService/services/ListPropertiesService.d.ts

@@ -1,8 +1,9 @@
 import { IProperty } from '../IProperty';
 import { IDesignItem } from '../../../item/IDesignItem';
 import { IJsonPropertyDefinitions } from './IJsonPropertyDefinitions';
-import { UnkownElementPropertiesService } from './UnkownElementPropertiesService';
-export declare class ListPropertiesService extends UnkownElementPropertiesService {
+import { AbstractPropertiesService } from './AbstractPropertiesService';
+export declare class ListPropertiesService extends AbstractPropertiesService {
+    listNeedsRefresh(designItem: IDesignItem): boolean;
     name: string;
     private _propertys;
     constructor(propertyDefinitions: IJsonPropertyDefinitions);

package/dist/elements/services/propertiesService/services/ListPropertiesService.js

@@ -1,6 +1,9 @@
-import { UnkownElementPropertiesService } from './UnkownElementPropertiesService';
+import { AbstractPropertiesService } from './AbstractPropertiesService';
 import { PropertyType } from '../PropertyType';
-export class ListPropertiesService extends UnkownElementPropertiesService {
+export class ListPropertiesService extends AbstractPropertiesService {
+    listNeedsRefresh(designItem) {
+        return false;
+    }
     name = "list";
     _propertys = new Map();
     constructor(propertyDefinitions) {

package/dist/elements/services/propertiesService/services/Lit2PropertiesService.d.ts

@@ -1,7 +1,7 @@
 import { IProperty } from '../IProperty';
 import { IDesignItem } from '../../../item/IDesignItem';
-import { AbstractBasePropertiesService } from "./AbstractBasePropertiesService";
-export declare class Lit2PropertiesService extends AbstractBasePropertiesService {
+import { AbstractPolymerLikePropertiesService } from "./AbstractPolymerLikePropertiesService";
+export declare class Lit2PropertiesService extends AbstractPolymerLikePropertiesService {
     name: string;
     isHandledElement(designItem: IDesignItem): boolean;
     getProperties(designItem: IDesignItem): IProperty[];

package/dist/elements/services/propertiesService/services/Lit2PropertiesService.js

@@ -1,7 +1,7 @@
-import { AbstractBasePropertiesService } from "./AbstractBasePropertiesService";
+import { AbstractPolymerLikePropertiesService } from "./AbstractPolymerLikePropertiesService";
 import { PropertiesHelper } from './PropertiesHelper';
 import { PropertyType } from '../PropertyType';
-export class Lit2PropertiesService extends AbstractBasePropertiesService {
+export class Lit2PropertiesService extends AbstractPolymerLikePropertiesService {
     name = "lit2";
     isHandledElement(designItem) {
         let prop = designItem.element.constructor.elementProperties;

package/dist/elements/services/propertiesService/services/LitElementPropertiesService.d.ts

@@ -1,7 +1,7 @@
 import { IProperty } from '../IProperty';
 import { IDesignItem } from '../../../item/IDesignItem';
-import { AbstractBasePropertiesService } from "./AbstractBasePropertiesService";
-export declare class LitElementPropertiesService extends AbstractBasePropertiesService {
+import { AbstractPolymerLikePropertiesService } from "./AbstractPolymerLikePropertiesService";
+export declare class LitElementPropertiesService extends AbstractPolymerLikePropertiesService {
     name: string;
     isHandledElement(designItem: IDesignItem): boolean;
     protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;

package/dist/elements/services/propertiesService/services/LitElementPropertiesService.js

@@ -1,5 +1,5 @@
-import { AbstractBasePropertiesService } from "./AbstractBasePropertiesService";
-export class LitElementPropertiesService extends AbstractBasePropertiesService {
+import { AbstractPolymerLikePropertiesService } from "./AbstractPolymerLikePropertiesService";
+export class LitElementPropertiesService extends AbstractPolymerLikePropertiesService {
     name = "lit";
     isHandledElement(designItem) {
         let proto = designItem.element.constructor.__proto__;

package/dist/elements/services/propertiesService/services/NativeElementsPropertiesService.js

@@ -67,6 +67,12 @@ export class NativeElementsPropertiesService extends CommonPropertiesService {
             type: "boolean",
             service: this,
             propertyType: PropertyType.propertyAndAttribute
+        }, {
+            name: "resize",
+            type: "list",
+            values: ["both", "none", "horizontal", "vertical"],
+            service: this,
+            propertyType: PropertyType.cssValue
         }
     ];
     selectProperties = [

package/dist/elements/services/propertiesService/services/PolymerPropertiesService.d.ts

@@ -1,7 +1,7 @@
 import { IProperty } from '../IProperty';
 import { IDesignItem } from '../../../item/IDesignItem';
-import { AbstractBasePropertiesService } from './AbstractBasePropertiesService';
-export declare class PolymerPropertiesService extends AbstractBasePropertiesService {
+import { AbstractPolymerLikePropertiesService } from './AbstractPolymerLikePropertiesService';
+export declare class PolymerPropertiesService extends AbstractPolymerLikePropertiesService {
     name: string;
     isHandledElement(designItem: IDesignItem): boolean;
     protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;

package/dist/elements/services/propertiesService/services/PolymerPropertiesService.js

@@ -1,5 +1,5 @@
-import { AbstractBasePropertiesService } from './AbstractBasePropertiesService';
-export class PolymerPropertiesService extends AbstractBasePropertiesService {
+import { AbstractPolymerLikePropertiesService } from './AbstractPolymerLikePropertiesService';
+export class PolymerPropertiesService extends AbstractPolymerLikePropertiesService {
     name = "polymer";
     isHandledElement(designItem) {
         return designItem.element.constructor.polymerElementVersion != null;

package/dist/elements/services/propertiesService/services/UnkownElementPropertiesService.d.ts

@@ -5,16 +5,16 @@ import { ValueType } from "../ValueType";
 import { BindingTarget } from "../../../item/BindingTarget";
 import { IBinding } from "../../../item/IBinding";
 export declare abstract class UnkownElementPropertiesService implements IPropertiesService {
-    listNeedsRefresh(designItem: IDesignItem): boolean;
-    isHandledElement(designItem: IDesignItem): boolean;
+    abstract listNeedsRefresh(designItem: IDesignItem): boolean;
+    abstract isHandledElement(designItem: IDesignItem): boolean;
     protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;
     getProperty(designItem: IDesignItem, name: string): IProperty;
-    getProperties(designItem: IDesignItem): IProperty[];
+    abstract getProperties(designItem: IDesignItem): IProperty[];
     setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
     getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
     clearValue(designItems: IDesignItem[], property: IProperty): void;
     isSet(designItems: IDesignItem[], property: IProperty): ValueType;
-    getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
     getValue(designItems: IDesignItem[], property: IProperty): string | boolean;
+    getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
     getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
 }

package/dist/elements/services/propertiesService/services/UnkownElementPropertiesService.js

@@ -1,29 +1,25 @@
 import { ValueType } from "../ValueType";
 import { PropertiesHelper } from './PropertiesHelper';
 import { BindingTarget } from "../../../item/BindingTarget";
-//@ts-ignore
+import { PropertyType } from "../PropertyType";
+import { NodeType } from "../../../item/NodeType";
 export class UnkownElementPropertiesService {
-    listNeedsRefresh(designItem) {
-        return true;
-    }
-    isHandledElement(designItem) {
-        return true;
-    }
     _notifyChangedProperty(designItem, property, value) {
     }
     getProperty(designItem, name) {
-        return null;
-    }
-    getProperties(designItem) {
-        return null;
+        return this.getProperties(designItem).find(x => x.name == name);
     }
     setValue(designItems, property, value) {
-        let attributeName = property.attributeName;
-        if (!attributeName)
-            attributeName = PropertiesHelper.camelToDashCase(property.name);
         const cg = designItems[0].openGroup("properties changed");
-        try {
-            for (let d of designItems) {
+        for (let d of designItems) {
+            if (property.propertyType == PropertyType.cssValue) {
+                d.styles.set(property.name, value);
+                d.element.style[property.name] = value;
+            }
+            else {
+                let attributeName = property.attributeName;
+                if (!attributeName)
+                    attributeName = PropertiesHelper.camelToDashCase(property.name);
                 if (property.type === 'object') {
                     const json = JSON.stringify(value);
                     d.attributes.set(attributeName, json);
@@ -41,77 +37,126 @@ export class UnkownElementPropertiesService {
                     d.attributes.set(attributeName, value);
                     d.element.setAttribute(attributeName, value);
                 }
-                this._notifyChangedProperty(d, property, value);
             }
-            cg.commit();
-        }
-        catch (err) {
-            console.log(err);
-            cg.undo();
+            this._notifyChangedProperty(d, property, value);
         }
+        cg.commit();
     }
     getPropertyTarget(designItem, property) {
         return BindingTarget.property;
     }
     clearValue(designItems, property) {
-        const attributeName = PropertiesHelper.camelToDashCase(property.name);
+        const cg = designItems[0].openGroup("properties cleared");
         for (let d of designItems) {
-            d.attributes.delete(attributeName);
-            d.element.removeAttribute(attributeName);
+            if (property.propertyType == PropertyType.cssValue) {
+                d.styles.delete(property.name);
+                d.element.style[property.name] = '';
+            }
+            else {
+                let attributeName = property.attributeName;
+                if (!attributeName)
+                    attributeName = PropertiesHelper.camelToDashCase(property.name);
+                d.attributes.delete(attributeName);
+                d.element.removeAttribute(attributeName);
+            }
             d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
                 return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
             });
             this._notifyChangedProperty(d, property, undefined);
         }
+        cg.commit();
     }
     isSet(designItems, property) {
         let all = true;
         let some = false;
         if (designItems != null && designItems.length !== 0) {
-            let attributeName = PropertiesHelper.camelToDashCase(property.name);
+            let attributeName = property.attributeName;
+            if (!attributeName)
+                attributeName = PropertiesHelper.camelToDashCase(property.name);
             designItems.forEach((x) => {
-                let has = x.attributes.has(attributeName);
+                let has = false;
+                if (property.propertyType == PropertyType.cssValue)
+                    has = x.styles.has(property.name);
+                else
+                    has = x.attributes.has(attributeName);
                 all = all && has;
                 some = some || has;
             });
-            //TODO: optimize perf, do not call bindings service for each property. 
+            //todo: optimize perf, do not call bindings service for each property. 
             const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
                 return s.getBindings(designItems[0]);
             });
-            if (bindings && bindings.find(x => (x.target == BindingTarget.property || x.target == BindingTarget.attribute) && x.targetName == property.name))
-                return ValueType.bound;
+            if (property.propertyType == PropertyType.cssValue) {
+                if (bindings && bindings.find(x => x.target == BindingTarget.css && x.targetName == property.name))
+                    return ValueType.bound;
+            }
+            else {
+                if (bindings && bindings.find(x => x.target == BindingTarget.property && x.targetName == property.name))
+                    return ValueType.bound;
+            }
         }
         else
             return ValueType.none;
         return all ? ValueType.all : some ? ValueType.some : ValueType.none;
     }
+    getValue(designItems, property) {
+        if (designItems != null && designItems.length !== 0) {
+            if (property.propertyType == PropertyType.cssValue) {
+                let lastValue = designItems[0].styles.get(property.name);
+                for (const x of designItems) {
+                    let value = x.styles.get(property.name);
+                    if (value != lastValue) {
+                        lastValue = null;
+                        break;
+                    }
+                }
+                return lastValue;
+            }
+            else {
+                let attributeName = property.attributeName;
+                if (!attributeName)
+                    attributeName = PropertiesHelper.camelToDashCase(property.name);
+                if (property.type == 'boolean')
+                    return designItems[0].attributes.has(attributeName);
+                let lastValue = designItems[0].attributes.get(attributeName);
+                /*
+                for (const x of designItems) {
+                  let value = x.attributes.get(attributeName);
+                  if (value != lastValue) {
+                    lastValue = null;
+                    break;
+                  }
+                }
+                */
+                return lastValue;
+            }
+        }
+        return null;
+    }
     getBinding(designItems, property) {
         //TODO: optimize perf, do not call bindings service for each property. 
         const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
             return s.getBindings(designItems[0]);
         });
-        return bindings.find(x => (x.target == BindingTarget.property || x.target == BindingTarget.attribute) && x.targetName == property.name);
-    }
-    getValue(designItems, property) {
-        if (designItems != null && designItems.length !== 0) {
-            let attributeName = PropertiesHelper.camelToDashCase(property.name);
-            if (property.type == 'boolean')
-                return designItems[0].attributes.has(attributeName);
-            let lastValue = designItems[0].attributes.get(attributeName);
-            /*
-            for (const x of designItems) {
-              let value = x.attributes.get(attributeName);
-              if (value != lastValue) {
-                lastValue = null;
-                break;
-              }
-            }
-            */
-            return lastValue;
+        if (property.propertyType == PropertyType.cssValue) {
+            return bindings.find(x => (x.target == BindingTarget.css) && x.targetName == property.name);
+        }
+        else {
+            return bindings.find(x => (x.target == BindingTarget.property || x.target == BindingTarget.attribute) && x.targetName == property.name);
         }
-        return null;
     }
+    //todo: optimize perf, call window.getComputedStyle only once per item, and not per property
     getUnsetValue(designItems, property) {
-        return property.defaultValue;
+        if (property.propertyType == PropertyType.cssValue) {
+            if (designItems != null && designItems.length !== 0) {
+                if (designItems[0].nodeType == NodeType.Element) {
+                    let v = window.getComputedStyle(designItems[0].element)[property.name];
+                    return v;
+                }
+            }
+            return null;
+        }
+        else
+            return property.defaultValue;
     }
 }

package/dist/elements/services/propertiesService/services/WebcomponentManifestPropertiesService.d.ts

@@ -2,8 +2,9 @@ import { BindingTarget } from "../../../item/BindingTarget.js";
 import { IDesignItem } from "../../../item/IDesignItem.js";
 import { IPropertiesService } from "../IPropertiesService.js";
 import { IProperty } from "../IProperty.js";
-import { UnkownElementPropertiesService } from "./UnkownElementPropertiesService.js";
-export declare class WebcomponentManifestPropertiesService extends UnkownElementPropertiesService implements IPropertiesService {
+import { AbstractPropertiesService } from "./AbstractPropertiesService.js";
+export declare class WebcomponentManifestPropertiesService extends AbstractPropertiesService implements IPropertiesService {
+    listNeedsRefresh(designItem: IDesignItem): boolean;
     private _name;
     get name(): string;
     private _propertiesList;

package/dist/elements/services/propertiesService/services/WebcomponentManifestPropertiesService.js

@@ -1,7 +1,10 @@
 import { BindingTarget } from "../../../item/BindingTarget.js";
 import { PropertyType } from "../PropertyType.js";
-import { UnkownElementPropertiesService } from "./UnkownElementPropertiesService.js";
-export class WebcomponentManifestPropertiesService extends UnkownElementPropertiesService {
+import { AbstractPropertiesService } from "./AbstractPropertiesService.js";
+export class WebcomponentManifestPropertiesService extends AbstractPropertiesService {
+    listNeedsRefresh(designItem) {
+        return false;
+    }
     _name;
     get name() { return this._name; }
     _propertiesList;

package/dist/elements/widgets/designerView/extensions/EditText/EditTextExtension.d.ts

@@ -2,16 +2,23 @@ import { IDesignItem } from "../../../../item/IDesignItem";
 import { IDesignerCanvas } from "../../IDesignerCanvas";
 import { AbstractExtension } from "../AbstractExtension.js";
 import { IExtensionManager } from "../IExtensionManger";
-export declare class EditTextExtension extends AbstractExtension {
+export declare type handlesPointerEvent = {
+    handlesPointerEvent(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): boolean;
+};
+export declare class EditTextExtension extends AbstractExtension implements handlesPointerEvent {
+    private static template;
     private _contentEditedBound;
     private _blurBound;
-    private static template;
     private _blurTimeout;
+    private _foreignObject;
+    private _focusBound;
     constructor(extensionManager: IExtensionManager, designerView: IDesignerCanvas, extendedItem: IDesignItem);
     extend(): void;
     refresh(): void;
     dispose(): void;
+    handlesPointerEvent(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): boolean;
     _contentEdited(): void;
     _blur(): void;
+    _focus(): void;
     _formatSelection(type: string): void;
 }