brighterscript 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/parser/SGTypes.js

@@ -1,151 +1,304 @@
 "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.SGFieldTypes = exports.SGFieldType = exports.SGInterfaceField = exports.SGScript = exports.SGCustomization = exports.SGChildren = exports.SGNode = exports.SGProlog = exports.SGElement = exports.SGAttribute = void 0;
 const source_map_1 = require("source-map");
 const creators_1 = require("../astUtils/creators");
-const xml_1 = require("../astUtils/xml");
 const util_1 = require("../util");
-class SGTag {
-    constructor(tag, attributes = [], range) {
-        this.tag = tag;
-        this.attributes = attributes;
-        this.range = range;
+class SGAttribute {
+    constructor(options) {
+        this._location = null;
+        this.tokens = {
+            key: options.key,
+            equals: options.equals,
+            openingQuote: options.openingQuote,
+            value: options.value,
+            closingQuote: options.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 location() {
+        if (!this._location) {
+            this._location = util_1.default.createBoundingLocation(this.tokens.key, this.tokens.equals, this.tokens.openingQuote, this.tokens.value, this.tokens.closingQuote);
+        }
+        return this._location;
+    }
+    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 util_1.default.sourceNodeFromTranspileResult(null, null, null, result);
+    }
+    clone() {
+        return new SGAttribute(this.tokens);
+    }
+}
+exports.SGAttribute = SGAttribute;
+class SGElement {
+    constructor(options) {
+        var _a, _b;
+        /**
+         * Array of attributes found on this tag
+         */
+        this.attributes = [];
+        /**
+         * The array of direct children AST elements of this AST node
+         */
+        this.elements = [];
+        this._location = null;
+        this.tokens = {
+            startTagOpen: options.startTagOpen,
+            startTagName: options.startTagName,
+            startTagClose: options.startTagClose,
+            endTagOpen: options.endTagOpen,
+            endTagName: options.endTagName,
+            endTagClose: options.endTagClose
+        };
+        this.attributes = (_a = options.attributes) !== null && _a !== void 0 ? _a : [];
+        this.elements = (_b = options.elements) !== null && _b !== void 0 ? _b : [];
+    }
+    get location() {
+        var _a, _b, _c, _d;
+        if (!this._location) {
+            this._location = util_1.default.createBoundingLocation(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.elements) === null || _c === void 0 ? void 0 : _c[((_d = this.elements) === null || _d === void 0 ? void 0 : _d.length) - 1], this.tokens.endTagOpen, this.tokens.endTagName, this.tokens.endTagClose);
+        }
+        return this._location;
+    }
+    /**
+     * Is this a self-closing tag?
+     */
+    get isSelfClosing() {
+        var _a;
+        return this.tokens.startTagClose && ((_a = this.tokens.startTagClose) === null || _a === void 0 ? void 0 : _a.text) !== '>';
     }
     get id() {
         return this.getAttributeValue('id');
     }
     set id(value) {
-        this.setAttribute('id', value);
+        this.setAttributeValue('id', value);
+    }
+    /**
+     * Get the 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.
+     *
+     */
+    getElementsByTagName(tagName) {
+        const result = [];
+        const lowerTagName = tagName.toLowerCase();
+        for (const el of this.elements) {
+            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.elements.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.elements.indexOf(tag);
+        if (idx > -1) {
+            this.elements.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 (case INsensitive)
+     */
     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) {
+        if (value === undefined) {
+            this.removeAttribute(name);
+        }
+        else {
+            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);
             }
+            attr.value = value;
         }
-        else if (value) {
-            this.attributes.push({
-                key: { text: name },
-                value: { text: value }
-            });
+    }
+    /**
+     * Remove an attribute by its name. DO NOT USE this to edit AST (use ASTEditor)
+     * @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 util_1.default.sourceNodeFromTranspileResult(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 && this.elements.length === 0) {
+            return util_1.default.sourceNodeFromTranspileResult(null, null, null, [
+                ' ',
+                state.transpileToken(this.tokens.startTagClose, '/>'),
+                state.newline
+            ]);
+        }
+        else {
+            // it is possible that the original tag isSelfClosing, but new elements have been added to it
+            // in that case, create a new startTagClose token for transpilation.
+            const startTagClose = this.isSelfClosing ? (0, creators_1.createSGToken)('>', this.tokens.startTagClose.location) : this.tokens.startTagClose;
+            const chunks = [
+                state.transpileToken(startTagClose, '>'),
+                state.newline
+            ];
+            state.blockDepth++;
+            for (const child of this.elements) {
+                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 util_1.default.sourceNodeFromTranspileResult(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.SGElement = SGElement;
+class SGProlog extends SGElement {
 }
 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);
-        }
-    }
+class SGNode extends SGElement {
 }
 exports.SGNode = SGNode;
-class SGChildren extends SGNode {
-    constructor(tag = { text: 'children' }, children = [], range) {
-        super(tag, [], children, range);
-    }
+class SGChildren extends SGElement {
 }
 exports.SGChildren = SGChildren;
-class SGScript extends SGTag {
-    constructor(tag = { text: 'script' }, attributes, cdata, range) {
-        super(tag, attributes, range);
-        this.cdata = cdata;
-        if (!attributes) {
-            this.type = 'text/brightscript';
-        }
-    }
+class SGCustomization extends SGElement {
+}
+exports.SGCustomization = SGCustomization;
+class SGScript extends SGElement {
     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 util_1.default.sourceNodeFromTranspileResult(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)) {
+                const clone = attr.clone();
+                clone.tokens.value.text.replace(bsExtensionRegexp, '.brs');
+                modifiedAttributes.push(clone);
             }
             else if (lowerKey === 'type') {
                 foundType = true;
-                if (attr.value.text.toLowerCase().endsWith('brighterscript')) {
-                    modifiedAttributes.push(util_1.default.cloneSGAttribute(attr, 'text/brightscript'));
+                if ((_c = attr.tokens.value) === null || _c === void 0 ? void 0 : _c.text.toLowerCase().endsWith('brighterscript')) {
+                    modifiedAttributes.push(attr.clone());
                 }
                 else {
                     modifiedAttributes.push(attr);
@@ -156,94 +309,141 @@ 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 SGElement {
     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);
     }
 }
-exports.SGField = SGField;
-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);
-    }
+exports.SGInterfaceField = SGInterfaceField;
+var SGFieldType;
+(function (SGFieldType) {
+    SGFieldType["integer"] = "integer";
+    SGFieldType["int"] = "int";
+    SGFieldType["longinteger"] = "longinteger";
+    SGFieldType["float"] = "float";
+    SGFieldType["string"] = "string";
+    SGFieldType["str"] = "str";
+    SGFieldType["boolean"] = "boolean";
+    SGFieldType["bool"] = "bool";
+    SGFieldType["vector2d"] = "vector2d";
+    SGFieldType["color"] = "color";
+    SGFieldType["time"] = "time";
+    SGFieldType["uri"] = "uri";
+    SGFieldType["node"] = "node";
+    SGFieldType["floatarray"] = "floatarray";
+    SGFieldType["intarray"] = "intarray";
+    SGFieldType["boolarray"] = "boolarray";
+    SGFieldType["stringarray"] = "stringarray";
+    SGFieldType["vector2darray"] = "vector2darray";
+    SGFieldType["colorarray"] = "colorarray";
+    SGFieldType["timearray"] = "timearray";
+    SGFieldType["nodearray"] = "nodearray";
+    SGFieldType["assocarray"] = "assocarray";
+    SGFieldType["array"] = "array";
+    SGFieldType["roarray"] = "roarray";
+    SGFieldType["rect2d"] = "rect2d";
+    SGFieldType["rect2darray"] = "rect2darray";
+})(SGFieldType = exports.SGFieldType || (exports.SGFieldType = {}));
+exports.SGFieldTypes = Object.keys(SGFieldType);
+class SGInterfaceFunction extends SGElement {
     get name() {
         return this.getAttributeValue('name');
     }
     set name(value) {
-        this.setAttribute('name', value);
+        this.setAttributeValue('name', value);
     }
 }
-exports.SGFunction = SGFunction;
-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}`);
-                }
+exports.SGInterfaceFunction = SGInterfaceFunction;
+class SGInterface extends SGElement {
+    get fields() {
+        return this.getElementsByTagName('field');
+    }
+    get functions() {
+        return this.getElementsByTagName('function');
+    }
+    get members() {
+        var _a;
+        const result = [];
+        for (const node of this.elements) {
+            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.elements) {
+            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.elements) {
+            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,101 +454,254 @@ 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.elements.length; i++) {
+            const node = this.elements[i];
+            if (((_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'field' && node.id === id) {
+                this.elements.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);
+        return this.functions.find(func => func.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);
+            func = this.addChild((0, creators_1.createSGInterfaceFunction)(name));
         }
-    }
-    transpileBody(state) {
-        const body = ['>\n'];
-        state.blockDepth++;
-        if (this.fields.length > 0) {
-            body.push(...this.fields.map(node => node.transpile(state)));
-        }
-        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.elements.length; i++) {
+            const node = this.elements[i];
+            if (((_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'function' && node.getAttributeValue('name') === name) {
+                this.elements.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}`);
-                }
-            }
+/**
+ * The `<component>` element in SceneGraph. Not to be confused about usages of components like `<Rectangle>`, those are considered `SGNode` instances.
+ */
+class SGComponent extends SGElement {
+    /**
+     * Get all the <Field> and <Function> elements across all <Interface> nodes in this component
+     */
+    get interfaceMembers() {
+        const members = [];
+        for (const ifaceNode of this.getElementsByTagName('interface')) {
+            members.push(...ifaceNode.members);
         }
-    }
+        return members;
+    }
+    get scriptElements() {
+        return this.getElementsByTagName('script');
+    }
+    /**
+     * Get the <interface> element from this component (if present), or undefined if not.
+     * NOTE: Roku supports and merges multiple <interface> elements in a component, but this
+     * property points to the FIRST one. If you need to check whether a member exists,
+     * look through `this.interfaceMemebers` instead.
+     */
+    get interfaceElement() {
+        return this.getElementsByTagName('interface')[0];
+    }
+    /**
+     * Get the `<children>` element of this component. (not to be confused with the AST `childTags` property).
+     * If there are multiope `<children>` elements, this function will return the last `<children>` tag because that's what Roku devices do.
+     */
+    get childrenElement() {
+        const children = this.getElementsByTagName('children');
+        return children[children.length - 1];
+    }
+    get customizationElements() {
+        return this.getElementsByTagName('customization');
+    }
+    /**
+     * Specifies the name of the component, that allows you to create the component in your application.
+     * For example, if the name of the component is `CastMemberInfo`, you could create instances of the component declaratively
+     * in a child node element of a component `<children>` element (`<CastMemberInfo/>`), or using BrightScript in a `<script>`
+     * element (`createObject("roSGNode","CastMemberInfo")`).
+     *
+     * The name attribute is case-sensitive. You cannot successfully create or declare a component unless the component name exactly
+     *  matches the name attribute, including case. Also be aware that two components with the exact same name in the same application
+     * components directory will have undefined and generally undesirable results if you attempt to create a component object with that name in the application.
+     */
     get name() {
         return this.getAttributeValue('name');
     }
     set name(value) {
-        this.setAttribute('name', value);
-    }
+        this.setAttributeValue('name', value);
+    }
+    /**
+     * Specifies the name of the built-in or extended SceneGraph scene or node class whose functionality is extended by this component.
+     *
+     * For example, `extends="Group"` specifies that the component has all of the functionality of the Group node class (it can have child nodes, has translation/scale/rotation fields, and so forth).
+     *
+     * By default, a component extends the Group node class.
+     */
     get extends() {
         return this.getAttributeValue('extends');
     }
     set extends(value) {
-        this.setAttribute('extends', value);
+        this.setAttributeValue('extends', value);
+    }
+    /**
+     * Specifies the ID of a node declared in the XML file to have the initial remote control focus when the component is instantiated.
+     */
+    get initialFocus() {
+        return this.getAttributeValue('initialFocus');
+    }
+    set initialFocus(value) {
+        this.setAttributeValue('initialFocus', value);
+    }
+    /**
+     * Specifies the version of the SceneGraph API. The default is 1.0 if not specified.
+     */
+    get version() {
+        return this.getAttributeValue('version');
+    }
+    set version(value) {
+        this.setAttributeValue('version', value);
+    }
+    /**
+     * Does the specified field exist in the component interface?
+     */
+    hasInterfaceField(id) {
+        for (const ifaceNode of this.getElementsByTagName('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.getElementsByTagName('interface')) {
+            if (ifaceNode.hasFunction(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get an interface field with the specified name
+     */
+    getInterfaceField(name) {
+        for (const ifaceNode of this.getElementsByTagName('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.elements) {
+            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.getElementsByTagName('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.getElementsByTagName('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.getElementsByTagName('interface')) {
+            if (ifaceNode.removeFunction(name)) {
+                return true;
+            }
         }
-        state.blockDepth--;
-        body.push(state.indentText, '</', this.tag.text, '>\n');
-        return body;
+        return false;
     }
 }
 exports.SGComponent = SGComponent;
 class SGAst {
-    constructor(prolog, root, component) {
-        this.prolog = prolog;
-        this.root = root;
-        this.component = component;
+    constructor(options = {}) {
+        this.prologElement = options.prologElement;
+        this.rootElement = options.rootElement;
+        this.componentElement = options.componentElement;
     }
     transpile(state) {
         const chunks = [];
         //write XML prolog
-        if (this.prolog) {
-            chunks.push(this.prolog.transpile(state));
+        if (this.prologElement) {
+            chunks.push(this.prologElement.transpile(state));
         }
-        if (this.component) {
+        if (this.componentElement) {
             //write content
-            chunks.push(this.component.transpile(state));
+            chunks.push(this.componentElement.transpile(state));
         }
-        return chunks;
+        return new source_map_1.SourceNode(null, null, null, chunks);
     }
 }
 exports.SGAst = SGAst;