@marko/language-tools 1.0.0

package/dist/parser.d.ts

@@ -0,0 +1,227 @@
+import { type Range, type Ranges, TagType } from "htmljs-parser";
+export type Repeated<T> = [T, ...T[]] | [...T[], T] | [T, ...T[], T];
+export type Repeatable<T> = undefined | Repeated<T>;
+export declare const UNFINISHED: number;
+export { getLines, getPosition, getLocation, type Range, type Ranges, type Position, type Location, } from "htmljs-parser";
+export type Parsed = ReturnType<typeof parse>;
+export declare enum NodeType {
+    Program = 0,
+    Tag = 1,
+    OpenTagName = 2,
+    ShorthandId = 3,
+    ShorthandClassName = 4,
+    TagTypeArgs = 5,
+    TagTypeParams = 6,
+    TagVar = 7,
+    TagArgs = 8,
+    TagParams = 9,
+    AttrNamed = 10,
+    AttrName = 11,
+    AttrArgs = 12,
+    AttrValue = 13,
+    AttrMethod = 14,
+    AttrSpread = 15,
+    AttrTag = 16,
+    Text = 17,
+    CDATA = 18,
+    Doctype = 19,
+    Declaration = 20,
+    Comment = 21,
+    Placeholder = 22,
+    Scriptlet = 23,
+    Import = 24,
+    Export = 25,
+    Class = 26,
+    Style = 27,
+    Static = 28
+}
+export declare namespace Node {
+    type AnyNode = Program | Tag | OpenTagName | ShorthandId | ShorthandClassName | TagTypeArgs | TagTypeParams | TagVar | TagArgs | TagParams | AttrNamed | AttrName | AttrArgs | AttrValue | AttrMethod | AttrSpread | AttrTag | Text | CDATA | Doctype | Declaration | Comment | Placeholder | Scriptlet | Import | Export | Class | Style | Static;
+    type ParentNode = Program | Tag | AttrTag;
+    type StaticNode = Import | Export | Class | Style | Static;
+    type ParentTag = Tag | AttrTag;
+    type AttrNode = AttrNamed | AttrSpread;
+    type ControlFlowTag = Tag & {
+        nameText: "if" | "else" | "else-if" | "for" | "while";
+        bodyType: TagType.html;
+    };
+    type ChildNode = Tag | AttrTag | Text | Doctype | Declaration | CDATA | Placeholder | Scriptlet;
+    interface Commentable {
+        comments: Repeatable<Comment>;
+    }
+    interface Program extends Range, Commentable {
+        type: NodeType.Program;
+        parent: undefined;
+        static: StaticNode[];
+        body: ChildNode[];
+    }
+    interface Tag extends Range, Commentable {
+        type: NodeType.Tag;
+        parent: ParentNode;
+        owner: undefined;
+        concise: boolean;
+        selfClosed: boolean;
+        hasAttrTags: boolean;
+        open: Range;
+        close: Range | undefined;
+        nameText: string | undefined;
+        bodyType: Exclude<TagType, "statement">;
+        name: OpenTagName;
+        var: TagVar | undefined;
+        args: TagArgs | undefined;
+        params: TagParams | undefined;
+        shorthandId: ShorthandId | undefined;
+        shorthandClassNames: Repeatable<ShorthandClassName>;
+        typeArgs: TagTypeArgs | undefined;
+        typeParams: TagTypeParams | undefined;
+        attrs: Repeatable<AttrNode>;
+        body: Repeatable<ChildNode>;
+    }
+    interface AttrTag extends Range, Commentable {
+        type: NodeType.AttrTag;
+        parent: ParentTag;
+        owner: ParentTag | undefined;
+        concise: boolean;
+        selfClosed: boolean;
+        hasAttrTags: boolean;
+        open: Range;
+        close: Range | undefined;
+        nameText: string;
+        bodyType: TagType.html;
+        name: OpenTagName;
+        var: TagVar | undefined;
+        args: TagArgs | undefined;
+        params: TagParams | undefined;
+        shorthandId: ShorthandId | undefined;
+        shorthandClassNames: Repeatable<ShorthandClassName>;
+        typeArgs: TagTypeArgs | undefined;
+        typeParams: TagTypeParams | undefined;
+        attrs: Repeatable<AttrNode>;
+        body: Repeatable<ChildNode>;
+    }
+    interface OpenTagName extends Ranges.Template {
+        type: NodeType.OpenTagName;
+        parent: ParentTag;
+    }
+    interface ShorthandId extends Ranges.Template {
+        type: NodeType.ShorthandId;
+        parent: ParentTag;
+    }
+    interface ShorthandClassName extends Ranges.Template {
+        type: NodeType.ShorthandClassName;
+        parent: ParentTag;
+    }
+    interface TagTypeArgs extends Ranges.Value {
+        type: NodeType.TagTypeArgs;
+        parent: ParentTag;
+    }
+    interface TagTypeParams extends Ranges.Value {
+        type: NodeType.TagTypeParams;
+        parent: ParentTag;
+    }
+    interface TagVar extends Ranges.Value {
+        type: NodeType.TagVar;
+        parent: ParentTag;
+    }
+    interface TagArgs extends Ranges.Value {
+        type: NodeType.TagArgs;
+        parent: ParentTag;
+    }
+    interface TagParams extends Ranges.Value {
+        type: NodeType.TagParams;
+        parent: ParentTag;
+    }
+    interface Text extends Range {
+        type: NodeType.Text;
+        parent: ParentNode;
+    }
+    interface CDATA extends Ranges.Value {
+        type: NodeType.CDATA;
+        parent: ParentNode;
+    }
+    interface Doctype extends Ranges.Value {
+        type: NodeType.Doctype;
+        parent: ParentNode;
+    }
+    interface Declaration extends Ranges.Value {
+        type: NodeType.Declaration;
+        parent: ParentNode;
+    }
+    interface Comment extends Ranges.Value {
+        type: NodeType.Comment;
+        parent: ParentNode;
+    }
+    interface Placeholder extends Ranges.Value, Commentable {
+        type: NodeType.Placeholder;
+        parent: ParentNode;
+        escape: boolean;
+    }
+    interface Scriptlet extends Ranges.Value, Commentable {
+        type: NodeType.Scriptlet;
+        parent: ParentNode;
+        block: boolean;
+    }
+    interface AttrNamed extends Range {
+        type: NodeType.AttrNamed;
+        parent: ParentTag;
+        name: AttrName;
+        args: undefined | AttrArgs;
+        value: undefined | AttrValue | AttrMethod;
+    }
+    interface AttrName extends Range {
+        type: NodeType.AttrName;
+        parent: AttrNamed;
+    }
+    interface AttrArgs extends Ranges.Value {
+        type: NodeType.AttrArgs;
+        parent: AttrNamed;
+    }
+    interface AttrValue extends Range {
+        type: NodeType.AttrValue;
+        parent: AttrNamed;
+        value: Range;
+        bound: boolean;
+    }
+    interface AttrMethod extends Range {
+        type: NodeType.AttrMethod;
+        parent: AttrNamed;
+        typeParams: undefined | Ranges.Value;
+        params: Range;
+        body: Range;
+    }
+    interface AttrSpread extends Ranges.Value {
+        type: NodeType.AttrSpread;
+        parent: ParentTag;
+    }
+    interface Import extends Range, Commentable {
+        type: NodeType.Import;
+        parent: ParentNode;
+    }
+    interface Export extends Range, Commentable {
+        type: NodeType.Export;
+        parent: ParentNode;
+    }
+    interface Class extends Range, Commentable {
+        type: NodeType.Class;
+        parent: ParentNode;
+    }
+    interface Style extends Range, Commentable {
+        type: NodeType.Style;
+        parent: ParentNode;
+        ext: string | undefined;
+        value: Range;
+    }
+    interface Static extends Range, Commentable {
+        type: NodeType.Static;
+        parent: ParentNode;
+    }
+}
+export declare function parse(code: string, filename?: string): {
+    read: (range: Range) => string;
+    locationAt: (range: Range) => import("htmljs-parser").Location;
+    positionAt: (offset: number) => import("htmljs-parser").Position;
+    nodeAt: (offset: number) => Node.AnyNode;
+    filename: string;
+    program: Node.Program;
+    code: string;
+};

package/dist/util/extractor.d.ts

@@ -0,0 +1,28 @@
+import { type Location, type Parsed, type Position, type Range } from "../parser";
+interface Token {
+    generatedStart: number;
+    sourceStart: number;
+    length: number;
+}
+/**
+ * Utility to build up generate code from source ranges while maintaining a source mapping.
+ */
+export declare class Extractor {
+    #private;
+    constructor(parsed: Parsed);
+    write(str: string): this;
+    copy(range: Range | string | false | void | null): this;
+    end(): Extracted;
+}
+export declare class Extracted {
+    #private;
+    constructor(parsed: Parsed, generated: string, tokens: Token[]);
+    sourceOffsetAt(generatedOffset: number): number | void;
+    sourcePositionAt(generatedOffset: number): Position | void;
+    sourceLocationAt(generatedStart: number, generatedEnd: number): Location | undefined;
+    generatedOffsetAt(sourceOffset: number): number | void;
+    generatedPositionAt(sourceOffset: number): Position | void;
+    generatedLocationAt(sourceStart: number, sourceEnd: number): Location | undefined;
+    toString(): string;
+}
+export {};

package/dist/util/get-node-at-offset.d.ts

@@ -0,0 +1,2 @@
+import { Node } from "../parser";
+export declare function getNodeAtOffset(offset: number, program: Node.Program): Node.AnyNode;