brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/parser/SGTypes.d.ts

@@ -1,53 +1,141 @@
 import { SourceNode } from 'source-map';
 import type { Range } from 'vscode-languageserver';
-import type { FileReference, TranspileResult } from '../interfaces';
+import type { FileReference } from '../interfaces';
+import { BooleanType } from '../types/BooleanType';
+import { DynamicType } from '../types/DynamicType';
+import { FloatType } from '../types/FloatType';
+import { FunctionType } from '../types/FunctionType';
+import { IntegerType } from '../types/IntegerType';
+import { LongIntegerType } from '../types/LongIntegerType';
+import { StringType } from '../types/StringType';
 import type { TranspileState } from './TranspileState';
 export interface SGToken {
     text: string;
     range?: Range;
 }
-export interface SGAttribute {
-    key: SGToken;
-    value: SGToken;
-    range?: Range;
+export declare class SGAttribute {
+    constructor(key: SGToken, equals?: SGToken, openingQuote?: SGToken, value?: SGToken, closingQuote?: SGToken);
+    tokens: {
+        key: SGToken;
+        equals?: SGToken;
+        openingQuote?: SGToken;
+        value?: SGToken;
+        closingQuote?: SGToken;
+    };
+    get key(): string;
+    /**
+     * The value of this attribute. This does not including the opening or closing quote
+     */
+    get value(): string | undefined;
+    set value(val: string | undefined);
+    get range(): Range;
+    private _range;
+    transpile(state: TranspileState): SourceNode;
 }
 export declare class SGTag {
-    tag: SGToken;
+    constructor(startTagOpen: SGToken, startTagName: SGToken, attributes?: SGAttribute[], startTagClose?: SGToken, childNodes?: SGTag[], endTagOpen?: SGToken, endTagName?: SGToken, endTagClose?: SGToken);
+    tokens: {
+        /**
+        * The first portion of the startTag. (i.e. `<` or `<?`)
+        */
+        startTagOpen: SGToken;
+        /**
+         * The name of the opening tag (i.e. CoolTag in `<CoolTag>`).
+         */
+        startTagName: SGToken;
+        /**
+         * The last bit of the startTag (i.e. `/>` for self-closing, `?>` for xml prologue, or `>` for tag with children)
+         */
+        startTagClose?: SGToken;
+        /**
+         * The endTag opening char `<`
+         */
+        endTagOpen?: SGToken;
+        /**
+         * The name of the ending tag (i.e. CoolTag in `</CoolTag>`)
+         */
+        endTagName?: SGToken;
+        /**
+         * The endTag closing char `>`
+         */
+        endTagClose?: SGToken;
+    };
+    /**
+     * Array of attributes found on this tag
+     */
     attributes: SGAttribute[];
-    range?: Range;
-    constructor(tag: SGToken, attributes?: SGAttribute[], range?: Range);
+    /**
+     * The array of direct children AST elements of this AST node
+     */
+    childNodes: SGTag[];
+    get range(): Range;
+    private _range;
+    /**
+     * Is this a self-closing tag?
+     */
+    get isSelfClosing(): boolean;
     get id(): string;
     set id(value: string);
+    /**
+     * Get the lower-case name of this tag.
+     */
+    get tagName(): string;
+    /**
+     * Find all direct children by their tag name (case insensitive).
+     * This does not step into children's children.
+     *
+     */
+    getChildNodesByTagName<T extends SGTag>(tagName: string): readonly T[];
+    /**
+     * Add a child to the end of the children array
+     */
+    addChild<T extends SGTag>(tag: T): T;
+    /**
+     * 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: SGTag): boolean;
+    /**
+     * Does this node have the specified attribute?
+     */
+    hasAttribute(name: string): boolean;
+    /**
+     * Get an SGAttribute by its name
+     */
     getAttribute(name: string): SGAttribute | undefined;
+    /**
+     * Get an attribute value by its name
+     */
     getAttributeValue(name: string): string | undefined;
-    setAttribute(name: string, value: string): void;
+    /**
+     * Set an attribute value by its name. If no attribute exists with this name, it is created
+     */
+    setAttributeValue(name: string, value: string): void;
+    /**
+     * Remove an attribute by its name
+     * @returns true if an attribute was found and removed. False if no attribute was found
+     */
+    removeAttribute(name: string): boolean;
     transpile(state: TranspileState): SourceNode;
-    protected transpileBody(state: TranspileState): (string | SourceNode)[];
-    protected transpileAttributes(state: TranspileState, attributes: SGAttribute[]): (string | SourceNode)[];
+    protected transpileBody(state: TranspileState): SourceNode;
+    protected transpileAttributes(state: TranspileState, attributes: SGAttribute[]): SourceNode;
 }
 export declare class SGProlog extends SGTag {
-    transpile(state: TranspileState): SourceNode;
 }
 export declare class SGNode extends SGTag {
-    children: SGNode[];
-    constructor(tag: SGToken, attributes?: SGAttribute[], children?: SGNode[], range?: Range);
-    protected transpileBody(state: TranspileState): (string | SourceNode)[];
 }
-export declare class SGChildren extends SGNode {
-    constructor(tag?: SGToken, children?: SGNode[], range?: Range);
+export declare class SGChildren extends SGTag {
 }
 export declare class SGScript extends SGTag {
     cdata?: SGToken;
-    constructor(tag?: SGToken, attributes?: SGAttribute[], cdata?: SGToken, range?: Range);
     get type(): string;
     set type(value: string);
     get uri(): string;
     set uri(value: string);
-    protected transpileBody(state: TranspileState): (string | SourceNode)[];
-    protected transpileAttributes(state: TranspileState, attributes: SGAttribute[]): (string | SourceNode)[];
+    protected transpileBody(state: TranspileState): SourceNode;
+    protected transpileAttributes(state: TranspileState, attributes: SGAttribute[]): SourceNode;
 }
-export declare class SGField extends SGTag {
-    constructor(tag?: SGToken, attributes?: SGAttribute[], range?: Range);
+export declare class SGInterfaceField extends SGTag {
     get type(): string;
     set type(value: string);
     get alias(): string;
@@ -58,33 +146,110 @@ export declare class SGField extends SGTag {
     set onChange(value: string);
     get alwaysNotify(): string;
     set alwaysNotify(value: string);
+    get bscType(): DynamicType | FloatType | IntegerType | LongIntegerType | StringType | BooleanType;
 }
 export declare const SGFieldTypes: string[];
-export declare class SGFunction extends SGTag {
-    constructor(tag?: SGToken, attributes?: SGAttribute[], range?: Range);
+export declare function getBscTypeFromSGFieldType(sgFieldType: string): DynamicType | FloatType | IntegerType | LongIntegerType | StringType | BooleanType;
+export declare class SGInterfaceFunction extends SGTag {
     get name(): string;
     set name(value: string);
+    get functionType(): FunctionType;
 }
+export declare type SGInterfaceMember = SGInterfaceField | SGInterfaceFunction;
 export declare class SGInterface extends SGTag {
-    fields: SGField[];
-    functions: SGFunction[];
-    constructor(tag?: SGToken, content?: SGTag[], range?: Range);
-    getField(id: string): SGField;
-    setField(id: string, type: string, onChange?: string, alwaysNotify?: boolean, alias?: string): void;
-    getFunction(name: string): SGFunction;
-    setFunction(name: string): void;
-    protected transpileBody(state: TranspileState): (string | SourceNode)[];
+    get fields(): readonly SGInterfaceField[];
+    get functions(): readonly SGInterfaceFunction[];
+    get members(): readonly SGInterfaceMember[];
+    /**
+     * Check if there's an SGField with the specified name
+     */
+    hasField(id: string): boolean;
+    /**
+     * Check if there's an SGFunction with the specified name
+     */
+    hasFunction(name: string): boolean;
+    /**
+     * Find a field by its ID
+     */
+    getField(id: string): SGInterfaceField;
+    /**
+     * Set the value of a field. Creates a new field if one does not already exist with this ID
+     */
+    setField(id: string, type: string, onChange?: string, alwaysNotify?: boolean, alias?: string): SGInterfaceField;
+    /**
+     * 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: string): boolean;
+    /**
+     * Get the interface function with the specified name
+     */
+    getFunction(name: string): SGInterfaceFunction;
+    /**
+     * Add or replace a function on the interface
+     */
+    setFunction(name: string): SGInterfaceFunction;
+    /**
+     * 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: string): boolean;
 }
 export declare class SGComponent extends SGTag {
-    constructor(tag?: SGToken, attributes?: SGAttribute[], content?: SGTag[], range?: Range);
-    api: SGInterface;
-    scripts: SGScript[];
-    children: SGChildren;
+    /**
+     * Get all the <Field> and <Function> elements across all <Interface> nodes in this component
+     */
+    get interfaceMembers(): readonly SGInterfaceMember[];
+    get scripts(): readonly SGScript[];
+    /**
+     * 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(): SGChildren;
     get name(): string;
     set name(value: string);
     get extends(): string;
     set extends(value: string);
-    protected transpileBody(state: TranspileState): (string | SourceNode)[];
+    /**
+     * Does the specified field exist in the component interface?
+     */
+    hasInterfaceField(id: string): boolean;
+    /**
+     * Does the specified function exist in the component interface?
+     */
+    hasInterfaceFunction(name: string): boolean;
+    /**
+     * Get an interface field with the specified name
+     */
+    getInterfaceField(name: string): SGInterfaceField | undefined;
+    /**
+     * Return the first SGInterface node found, or insert a new one then return it
+     */
+    private ensureInterfaceNode;
+    /**
+     * Create or update a <field> interface element.
+     * This will create a new `<interface>` element if there are none on the component already
+     */
+    setInterfaceField(id: string, type: string, onChange?: string, alwaysNotify?: boolean, alias?: string): SGInterfaceField;
+    /**
+     * Create or update a <function> interface element.
+     * This will create a new `<interface>` element if there are none on the component already
+     */
+    setInterfaceFunction(name: string): SGInterfaceFunction;
+    /**
+     * 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: string): boolean;
+    /**
+    * Get an interface field with the specified name
+    */
+    getInterfaceFunction(name: string): SGInterfaceFunction | undefined;
+    /**
+     * 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: string): boolean;
 }
 export interface SGReferences {
     name?: SGToken;
@@ -96,5 +261,5 @@ export declare class SGAst {
     root?: SGTag;
     component?: SGComponent;
     constructor(prolog?: SGProlog, root?: SGTag, component?: SGComponent);
-    transpile(state: TranspileState): TranspileResult;
+    transpile(state: TranspileState): SourceNode;
 }