brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/parser/SGTypes.js

@@ -1,150 +1,293 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SGAst = exports.SGComponent = exports.SGInterface = exports.SGFunction = exports.SGFieldTypes = exports.SGField = exports.SGScript = exports.SGChildren = exports.SGNode = exports.SGProlog = exports.SGTag = void 0;
+exports.SGAst = exports.SGComponent = exports.SGInterface = exports.SGInterfaceFunction = exports.getBscTypeFromSGFieldType = exports.SGFieldTypes = exports.SGInterfaceField = exports.SGScript = exports.SGCustomization = exports.SGChildren = exports.SGNode = exports.SGProlog = exports.SGTag = exports.SGAttribute = void 0;
 const source_map_1 = require("source-map");
 const creators_1 = require("../astUtils/creators");
-const xml_1 = require("../astUtils/xml");
+const BooleanType_1 = require("../types/BooleanType");
+const DynamicType_1 = require("../types/DynamicType");
+const FloatType_1 = require("../types/FloatType");
+const TypedFunctionType_1 = require("../types/TypedFunctionType");
+const IntegerType_1 = require("../types/IntegerType");
+const LongIntegerType_1 = require("../types/LongIntegerType");
+const StringType_1 = require("../types/StringType");
 const util_1 = require("../util");
+class SGAttribute {
+    constructor(key, equals, openingQuote, value, closingQuote) {
+        this.tokens = {};
+        this._range = null;
+        this.tokens.key = key;
+        this.tokens.equals = equals;
+        this.tokens.openingQuote = openingQuote;
+        this.tokens.value = value;
+        this.tokens.closingQuote = closingQuote;
+    }
+    get key() {
+        return this.tokens.key.text;
+    }
+    /**
+     * The value of this attribute. This does not including the opening or closing quote
+     */
+    get value() {
+        var _a;
+        return (_a = this.tokens.value) === null || _a === void 0 ? void 0 : _a.text;
+    }
+    set value(val) {
+        if (val === null || val === undefined) {
+            val = '';
+        }
+        if (!this.tokens.equals) {
+            this.tokens.equals = { text: '=' };
+        }
+        if (this.tokens.value) {
+            this.tokens.value.text = val;
+        }
+        else {
+            this.tokens.value = { text: val };
+        }
+    }
+    get range() {
+        if (!this._range) {
+            this._range = util_1.default.createBoundingRange(this.tokens.key, this.tokens.equals, this.tokens.openingQuote, this.tokens.value, this.tokens.closingQuote);
+        }
+        return this._range;
+    }
+    transpile(state) {
+        const result = [
+            state.transpileToken(this.tokens.key)
+        ];
+        if (this.tokens.value) {
+            result.push(state.transpileToken(this.tokens.equals, '='), state.transpileToken(this.tokens.openingQuote, '"'), state.transpileToken(this.tokens.value), state.transpileToken(this.tokens.closingQuote, '"'));
+        }
+        return new source_map_1.SourceNode(null, null, null, result);
+    }
+}
+exports.SGAttribute = SGAttribute;
 class SGTag {
-    constructor(tag, attributes = [], range) {
-        this.tag = tag;
+    constructor(startTagOpen, startTagName, attributes = [], startTagClose, childNodes = [], endTagOpen, endTagName, endTagClose) {
+        this.tokens = {};
+        /**
+         * Array of attributes found on this tag
+         */
+        this.attributes = [];
+        /**
+         * The array of direct children AST elements of this AST node
+         */
+        this.childNodes = [];
+        this._range = null;
+        this.tokens.startTagOpen = startTagOpen;
+        this.tokens.startTagName = startTagName;
         this.attributes = attributes;
-        this.range = range;
+        this.tokens.startTagClose = startTagClose;
+        this.childNodes = childNodes;
+        this.tokens.endTagOpen = endTagOpen;
+        this.tokens.endTagName = endTagName;
+        this.tokens.endTagClose = endTagClose;
+    }
+    get range() {
+        var _a, _b, _c, _d;
+        if (!this._range) {
+            this._range = util_1.default.createBoundingRange(this.tokens.startTagOpen, this.tokens.startTagName, (_a = this.attributes) === null || _a === void 0 ? void 0 : _a[((_b = this.attributes) === null || _b === void 0 ? void 0 : _b.length) - 1], this.tokens.startTagClose, (_c = this.childNodes) === null || _c === void 0 ? void 0 : _c[((_d = this.childNodes) === null || _d === void 0 ? void 0 : _d.length) - 1], this.tokens.endTagOpen, this.tokens.endTagName, this.tokens.endTagClose);
+        }
+        return this._range;
+    }
+    /**
+     * Is this a self-closing tag?
+     */
+    get isSelfClosing() {
+        return !this.tokens.endTagName;
     }
     get id() {
         return this.getAttributeValue('id');
     }
     set id(value) {
-        this.setAttribute('id', value);
+        this.setAttributeValue('id', value);
+    }
+    /**
+     * Get the lower-case name of this tag.
+     */
+    get tagName() {
+        var _a;
+        return (_a = this.tokens.startTagName) === null || _a === void 0 ? void 0 : _a.text;
+    }
+    /**
+     * Find all direct children by their tag name (case insensitive).
+     * This does not step into children's children.
+     *
+     */
+    getChildNodesByTagName(tagName) {
+        const result = [];
+        const lowerTagName = tagName.toLowerCase();
+        for (const el of this.childNodes) {
+            if (el.tokens.startTagName.text.toLowerCase() === lowerTagName) {
+                result.push(el);
+            }
+        }
+        return result;
     }
+    /**
+     * Add a child to the end of the children array
+     */
+    addChild(tag) {
+        this.childNodes.push(tag);
+        return tag;
+    }
+    /**
+     * Remove a child from the children array.
+     * @returns true if node was found and removed, false if the node wasn't there and thus nothing was done
+     */
+    removeChild(tag) {
+        const idx = this.childNodes.indexOf(tag);
+        if (idx > -1) {
+            this.childNodes.splice(idx, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Does this node have the specified attribute?
+     */
+    hasAttribute(name) {
+        return !!this.getAttribute(name);
+    }
+    /**
+     * Get an SGAttribute by its name
+     */
     getAttribute(name) {
-        return this.attributes.find(att => att.key.text.toLowerCase() === name);
+        var _a;
+        const nameLower = name.toLowerCase();
+        for (const attr of this.attributes) {
+            if (((_a = attr.tokens.key) === null || _a === void 0 ? void 0 : _a.text.toLowerCase()) === nameLower) {
+                return attr;
+            }
+        }
     }
+    /**
+     * Get an attribute value by its name
+     */
     getAttributeValue(name) {
         var _a, _b;
-        return (_b = (_a = this.getAttribute(name)) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.text;
-    }
-    setAttribute(name, value) {
-        const attr = this.getAttribute(name);
-        if (attr) {
-            if (value) {
-                attr.value = { text: value };
-                attr.range = undefined;
-            }
-            else {
-                this.attributes.splice(this.attributes.indexOf(attr), 1);
-            }
+        return (_b = (_a = this.getAttribute(name)) === null || _a === void 0 ? void 0 : _a.tokens.value) === null || _b === void 0 ? void 0 : _b.text;
+    }
+    /**
+     * Set an attribute value by its name. If no attribute exists with this name, it is created
+     */
+    setAttributeValue(name, value) {
+        let attr = this.getAttribute(name);
+        //create an attribute with this name if we don't have one yet
+        if (!attr) {
+            attr = (0, creators_1.createSGAttribute)(name, value);
+            this.attributes.push(attr);
         }
-        else if (value) {
-            this.attributes.push({
-                key: { text: name },
-                value: { text: value }
-            });
+        attr.value = value;
+    }
+    /**
+     * Remove an attribute by its name
+     * @returns true if an attribute was found and removed. False if no attribute was found
+     */
+    removeAttribute(name) {
+        var _a;
+        const nameLower = name.toLowerCase();
+        for (let i = 0; i < this.attributes.length; i++) {
+            if (((_a = this.attributes[i].key) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === nameLower) {
+                this.attributes.splice(i, 1);
+                return true;
+            }
         }
+        return false;
     }
     transpile(state) {
-        return new source_map_1.SourceNode(null, null, state.srcPath, [
-            state.indentText,
-            '<',
-            state.transpileToken(this.tag),
-            ...this.transpileAttributes(state, this.attributes),
-            ...this.transpileBody(state)
+        return new source_map_1.SourceNode(null, null, null, [
+            state.transpileToken(this.tokens.startTagOpen, '<'),
+            state.transpileToken(this.tokens.startTagName),
+            this.transpileAttributes(state, this.attributes),
+            this.transpileBody(state)
         ]);
     }
     transpileBody(state) {
-        return [' />\n'];
+        var _a;
+        if (this.isSelfClosing) {
+            return new source_map_1.SourceNode(null, null, null, [
+                ' ',
+                state.transpileToken(this.tokens.startTagClose, '/>'),
+                state.newline
+            ]);
+        }
+        else {
+            const chunks = [
+                state.transpileToken(this.tokens.startTagClose, '>'),
+                state.newline
+            ];
+            state.blockDepth++;
+            for (const child of this.childNodes) {
+                chunks.push(state.indentText, child.transpile(state));
+            }
+            state.blockDepth--;
+            chunks.push(state.indentText, state.transpileToken(this.tokens.endTagOpen, '</'), state.transpileToken((_a = this.tokens.endTagName) !== null && _a !== void 0 ? _a : this.tokens.startTagName), state.transpileToken(this.tokens.endTagClose, '>'), state.newline);
+            return new source_map_1.SourceNode(null, null, null, chunks);
+        }
     }
     transpileAttributes(state, attributes) {
-        const result = [];
+        const chunks = [];
         for (const attr of attributes) {
-            result.push(' ', state.transpileToken(attr.key), '="', state.transpileToken(attr.value), '"');
+            chunks.push(' ', attr.transpile(state));
         }
-        return result;
+        return new source_map_1.SourceNode(null, null, null, chunks);
     }
 }
 exports.SGTag = SGTag;
 class SGProlog extends SGTag {
-    transpile(state) {
-        return new source_map_1.SourceNode(null, null, state.srcPath, [
-            '<?xml',
-            ...this.transpileAttributes(state, this.attributes),
-            ' ?>\n'
-        ]);
-    }
 }
 exports.SGProlog = SGProlog;
 class SGNode extends SGTag {
-    constructor(tag, attributes, children = [], range) {
-        super(tag, attributes, range);
-        this.children = children;
-    }
-    transpileBody(state) {
-        if (this.children.length > 0) {
-            const body = ['>\n'];
-            state.blockDepth++;
-            body.push(...this.children.map(node => node.transpile(state)));
-            state.blockDepth--;
-            body.push(state.indentText, '</', this.tag.text, '>\n');
-            return body;
-        }
-        else {
-            return super.transpileBody(state);
-        }
-    }
 }
 exports.SGNode = SGNode;
-class SGChildren extends SGNode {
-    constructor(tag = { text: 'children' }, children = [], range) {
-        super(tag, [], children, range);
-    }
+class SGChildren extends SGTag {
 }
 exports.SGChildren = SGChildren;
+class SGCustomization extends SGTag {
+}
+exports.SGCustomization = SGCustomization;
 class SGScript extends SGTag {
-    constructor(tag = { text: 'script' }, attributes, cdata, range) {
-        super(tag, attributes, range);
-        this.cdata = cdata;
-        if (!attributes) {
-            this.type = 'text/brightscript';
-        }
-    }
     get type() {
         return this.getAttributeValue('type');
     }
     set type(value) {
-        this.setAttribute('type', value);
+        this.setAttributeValue('type', value);
     }
     get uri() {
         return this.getAttributeValue('uri');
     }
     set uri(value) {
-        this.setAttribute('uri', value);
+        this.setAttributeValue('uri', value);
     }
     transpileBody(state) {
         if (this.cdata) {
-            return [
+            return new source_map_1.SourceNode(null, null, null, [
                 '>',
                 state.transpileToken(this.cdata),
                 '</',
-                this.tag.text,
-                '>\n'
-            ];
+                this.tokens.startTagName.text,
+                '>',
+                state.newline
+            ]);
         }
         else {
             return super.transpileBody(state);
         }
     }
     transpileAttributes(state, attributes) {
+        var _a, _b, _c;
         const modifiedAttributes = [];
         let foundType = false;
         const bsExtensionRegexp = /\.bs$/i;
         for (const attr of attributes) {
-            const lowerKey = attr.key.text.toLowerCase();
-            if (lowerKey === 'uri' && bsExtensionRegexp.exec(attr.value.text)) {
-                modifiedAttributes.push(util_1.default.cloneSGAttribute(attr, attr.value.text.replace(bsExtensionRegexp, '.brs')));
+            const lowerKey = (_a = attr.tokens.key) === null || _a === void 0 ? void 0 : _a.text.toLowerCase();
+            if (lowerKey === 'uri' && bsExtensionRegexp.exec((_b = attr.tokens.value) === null || _b === void 0 ? void 0 : _b.text)) {
+                modifiedAttributes.push(util_1.default.cloneSGAttribute(attr, attr.tokens.value.text.replace(bsExtensionRegexp, '.brs')));
             }
             else if (lowerKey === 'type') {
                 foundType = true;
-                if (attr.value.text.toLowerCase().endsWith('brighterscript')) {
+                if ((_c = attr.tokens.value) === null || _c === void 0 ? void 0 : _c.text.toLowerCase().endsWith('brighterscript')) {
                     modifiedAttributes.push(util_1.default.cloneSGAttribute(attr, 'text/brightscript'));
                 }
                 else {
@@ -156,94 +299,152 @@ class SGScript extends SGTag {
             }
         }
         if (!foundType) {
-            modifiedAttributes.push(creators_1.createSGAttribute('type', 'text/brightscript'));
+            modifiedAttributes.push((0, creators_1.createSGAttribute)('type', 'text/brightscript'));
         }
         return super.transpileAttributes(state, modifiedAttributes);
     }
 }
 exports.SGScript = SGScript;
-class SGField extends SGTag {
-    constructor(tag = { text: 'field' }, attributes = [], range) {
-        super(tag, attributes, range);
-    }
+class SGInterfaceField extends SGTag {
     get type() {
         return this.getAttributeValue('type');
     }
     set type(value) {
-        this.setAttribute('type', value);
+        this.setAttributeValue('type', value);
     }
     get alias() {
         return this.getAttributeValue('alias');
     }
     set alias(value) {
-        this.setAttribute('alias', value);
+        this.setAttributeValue('alias', value);
     }
     get value() {
         return this.getAttributeValue('value');
     }
     set value(value) {
-        this.setAttribute('value', value);
+        this.setAttributeValue('value', value);
     }
     get onChange() {
         return this.getAttributeValue('onChange');
     }
     set onChange(value) {
-        this.setAttribute('onChange', value);
+        this.setAttributeValue('onChange', value);
     }
     get alwaysNotify() {
         return this.getAttributeValue('alwaysNotify');
     }
     set alwaysNotify(value) {
-        this.setAttribute('alwaysNotify', value);
+        this.setAttributeValue('alwaysNotify', value);
+    }
+    get bscType() {
+        return getBscTypeFromSGFieldType(this.type);
     }
 }
-exports.SGField = SGField;
+exports.SGInterfaceField = SGInterfaceField;
 exports.SGFieldTypes = [
     'integer', 'int', 'longinteger', 'float', 'string', 'str', 'boolean', 'bool',
     'vector2d', 'color', 'time', 'uri', 'node', 'floatarray', 'intarray', 'boolarray',
     'stringarray', 'vector2darray', 'colorarray', 'timearray', 'nodearray', 'assocarray',
     'array', 'roarray', 'rect2d', 'rect2darray'
 ];
-class SGFunction extends SGTag {
-    constructor(tag = { text: 'function' }, attributes = [], range) {
-        super(tag, attributes, range);
+function getBscTypeFromSGFieldType(sgFieldType) {
+    switch (sgFieldType) {
+        case 'integer':
+        case 'int': {
+            return new IntegerType_1.IntegerType();
+        }
+        case 'longinteger': {
+            return new LongIntegerType_1.LongIntegerType();
+        }
+        case 'float': {
+            return new FloatType_1.FloatType();
+        }
+        case 'string':
+        case 'str': {
+            return new StringType_1.StringType();
+        }
+        case 'boolean':
+        case 'bool': {
+            return new BooleanType_1.BooleanType();
+        }
+        default: {
+            return new DynamicType_1.DynamicType();
+        }
     }
+}
+exports.getBscTypeFromSGFieldType = getBscTypeFromSGFieldType;
+class SGInterfaceFunction extends SGTag {
     get name() {
         return this.getAttributeValue('name');
     }
     set name(value) {
-        this.setAttribute('name', value);
+        this.setAttributeValue('name', value);
+    }
+    get functionType() {
+        const funcType = new TypedFunctionType_1.TypedFunctionType(new DynamicType_1.DynamicType());
+        funcType.name = this.name;
+        // TODO TYPES: Need to get parameter count/type for these functions for @callFunc usage
+        return funcType;
     }
 }
-exports.SGFunction = SGFunction;
+exports.SGInterfaceFunction = SGInterfaceFunction;
 class SGInterface extends SGTag {
-    constructor(tag = { text: 'interface' }, content, range) {
-        super(tag, [], range);
-        this.fields = [];
-        this.functions = [];
-        if (content) {
-            for (const tag of content) {
-                if (xml_1.isSGField(tag)) {
-                    this.fields.push(tag);
-                }
-                else if (xml_1.isSGFunction(tag)) {
-                    this.functions.push(tag);
-                }
-                else {
-                    throw new Error(`Unexpected tag ${tag.tag.text}`);
-                }
+    get fields() {
+        return this.getChildNodesByTagName('field');
+    }
+    get functions() {
+        return this.getChildNodesByTagName('function');
+    }
+    get members() {
+        var _a;
+        const result = [];
+        for (const node of this.childNodes) {
+            const tagName = (_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (tagName === 'field' || tagName === 'function') {
+                result.push(node);
             }
         }
+        return result;
     }
+    /**
+     * Check if there's an SGField with the specified name
+     */
+    hasField(id) {
+        var _a;
+        for (const node of this.childNodes) {
+            const tagName = (_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (tagName === 'field' && node.id === id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if there's an SGFunction with the specified name
+     */
+    hasFunction(name) {
+        var _a;
+        for (const node of this.childNodes) {
+            const tagName = (_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (tagName === 'function' && node.name === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Find a field by its ID
+     */
     getField(id) {
         return this.fields.find(field => field.id === id);
     }
+    /**
+     * Set the value of a field. Creates a new field if one does not already exist with this ID
+     */
     setField(id, type, onChange, alwaysNotify, alias) {
         let field = this.getField(id);
         if (!field) {
-            field = new SGField();
-            field.id = id;
-            this.fields.push(field);
+            field = this.addChild((0, creators_1.createSGInterfaceField)(id));
         }
         field.type = type;
         field.onChange = onChange;
@@ -254,81 +455,189 @@ class SGInterface extends SGTag {
             field.alwaysNotify = alwaysNotify ? 'true' : 'false';
         }
         field.alias = alias;
+        return field;
+    }
+    /**
+     * Remove a field from the interface
+     * @returns true if a field was found and removed. Returns false if no field was found with that name
+     */
+    removeField(id) {
+        var _a;
+        for (let i = 0; i < this.childNodes.length; i++) {
+            const node = this.childNodes[i];
+            const tagName = (_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (tagName === 'field' && node.id === id) {
+                this.childNodes.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
     }
+    /**
+     * Get the interface function with the specified name
+     */
     getFunction(name) {
         return this.functions.find(field => field.name === name);
     }
+    /**
+     * Add or replace a function on the interface
+     */
     setFunction(name) {
         let func = this.getFunction(name);
         if (!func) {
-            func = new SGFunction();
-            func.name = name;
-            this.functions.push(func);
-        }
-    }
-    transpileBody(state) {
-        const body = ['>\n'];
-        state.blockDepth++;
-        if (this.fields.length > 0) {
-            body.push(...this.fields.map(node => node.transpile(state)));
+            func = this.addChild((0, creators_1.createSGInterfaceFunction)(name));
         }
-        if (this.functions.length > 0) {
-            body.push(...this.functions.map(node => node.transpile(state)));
+        return func;
+    }
+    /**
+     * Remove a function from the interface
+     * @returns true if a function was found and removed. Returns false if no function was found with that name
+     */
+    removeFunction(name) {
+        var _a;
+        for (let i = 0; i < this.childNodes.length; i++) {
+            const node = this.childNodes[i];
+            const tagName = (_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (tagName === 'function' && node.getAttributeValue('name') === name) {
+                this.childNodes.splice(i, 1);
+                return true;
+            }
         }
-        state.blockDepth--;
-        body.push(state.indentText, '</', this.tag.text, '>\n');
-        return body;
+        return false;
     }
 }
 exports.SGInterface = SGInterface;
 class SGComponent extends SGTag {
-    constructor(tag = { text: 'component' }, attributes, content, range) {
-        super(tag, attributes, range);
-        this.scripts = [];
-        if (content) {
-            for (const tag of content) {
-                if (xml_1.isSGInterface(tag)) {
-                    this.api = tag;
-                }
-                else if (xml_1.isSGScript(tag)) {
-                    this.scripts.push(tag);
-                }
-                else if (xml_1.isSGChildren(tag)) {
-                    this.children = tag;
-                }
-                else {
-                    throw new Error(`Unexpected tag ${tag.tag.text}`);
-                }
-            }
+    /**
+     * Get all the <Field> and <Function> elements across all <Interface> nodes in this component
+     */
+    get interfaceMembers() {
+        const members = [];
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            members.push(...ifaceNode.members);
         }
+        return members;
+    }
+    get scripts() {
+        return this.getChildNodesByTagName('script');
+    }
+    /**
+     * Get the `<children>` element of this component. (not to be confused with the AST `childNodes` property).
+     * If there are multiope `<children>` elements, this function will return the last `<children>` tag because that's what Roku devices do.
+     */
+    get children() {
+        const children = this.getChildNodesByTagName('children');
+        return children[children.length - 1];
+    }
+    get customizations() {
+        return this.getChildNodesByTagName('customization');
     }
     get name() {
         return this.getAttributeValue('name');
     }
     set name(value) {
-        this.setAttribute('name', value);
+        this.setAttributeValue('name', value);
     }
     get extends() {
         return this.getAttributeValue('extends');
     }
     set extends(value) {
-        this.setAttribute('extends', value);
+        this.setAttributeValue('extends', value);
+    }
+    /**
+     * Does the specified field exist in the component interface?
+     */
+    hasInterfaceField(id) {
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            if (ifaceNode.hasField(id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Does the specified function exist in the component interface?
+     */
+    hasInterfaceFunction(name) {
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            if (ifaceNode.hasFunction(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get an interface field with the specified name
+     */
+    getInterfaceField(name) {
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            const field = ifaceNode.getField(name);
+            if (field) {
+                return field;
+            }
+        }
     }
-    transpileBody(state) {
-        const body = ['>\n'];
-        state.blockDepth++;
-        if (this.api) {
-            body.push(this.api.transpile(state));
+    /**
+     * Return the first SGInterface node found, or insert a new one then return it
+     */
+    ensureInterfaceNode() {
+        for (const el of this.childNodes) {
+            if (el.tokens.startTagName.text.toLowerCase() === 'interface') {
+                return el;
+            }
+        }
+        return this.addChild((0, creators_1.createSGInterface)());
+    }
+    /**
+     * Create or update a <field> interface element.
+     * This will create a new `<interface>` element if there are none on the component already
+     */
+    setInterfaceField(id, type, onChange, alwaysNotify, alias) {
+        let ifaceNode = this.ensureInterfaceNode();
+        return ifaceNode.setField(id, type, onChange, alwaysNotify, alias);
+    }
+    /**
+     * Create or update a <function> interface element.
+     * This will create a new `<interface>` element if there are none on the component already
+     */
+    setInterfaceFunction(name) {
+        let ifaceNode = this.ensureInterfaceNode();
+        return ifaceNode.setFunction(name);
+    }
+    /**
+     * Remove an interface field.
+     * @returns true if a field was found and removed. Returns false if no field was found with that name
+     */
+    removeInterfaceField(id) {
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            if (ifaceNode.removeField(id)) {
+                return true;
+            }
         }
-        if (this.scripts.length > 0) {
-            body.push(...this.scripts.map(node => node.transpile(state)));
+        return false;
+    }
+    /**
+    * Get an interface field with the specified name
+    */
+    getInterfaceFunction(name) {
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            const func = ifaceNode.getFunction(name);
+            if (func) {
+                return func;
+            }
         }
-        if (this.children) {
-            body.push(this.children.transpile(state));
+    }
+    /**
+     * Remove an interface function.
+     * @returns true if a function was found and removed. Returns false if no function was found with that name
+     */
+    removeInterfaceFunction(name) {
+        for (const ifaceNode of this.getChildNodesByTagName('interface')) {
+            if (ifaceNode.removeFunction(name)) {
+                return true;
+            }
         }
-        state.blockDepth--;
-        body.push(state.indentText, '</', this.tag.text, '>\n');
-        return body;
+        return false;
     }
 }
 exports.SGComponent = SGComponent;
@@ -348,7 +657,7 @@ class SGAst {
             //write content
             chunks.push(this.component.transpile(state));
         }
-        return chunks;
+        return new source_map_1.SourceNode(null, null, null, chunks);
     }
 }
 exports.SGAst = SGAst;