@visuallyjs/browser-ui 1.0.0

package/types/core/selection.d.ts

@@ -0,0 +1,394 @@
+import { DataSource, ObjectInfo } from "./datasource";
+import { EVENT_DATA_LOAD_END, EVENT_DATA_LOAD_START, EVENT_EDGE_ADDED, EVENT_EDGE_REMOVED, EVENT_EDGE_SOURCE_CHANGED, EVENT_EDGE_TARGET_CHANGED, EVENT_EDGE_UPDATED, EVENT_GRAPH_CLEAR_START, EVENT_GROUP_UPDATED, EVENT_NODE_ADDED, EVENT_NODE_REMOVED, EVENT_NODE_UPDATED, EVENT_PORT_UPDATED } from "./event-constants";
+import { VisuallyJsModel, ObjectFactory } from "./toolkit";
+import { Graph, Base, Port, Group, Node, Edge, Vertex } from "./model/graph";
+import { DataModel } from "./datamodel/data-model";
+import { Path } from "./model/path";
+import { OptimisticEventGenerator } from "./event-generator";
+import { EVENT_GROUP_ADDED, EVENT_GROUP_REMOVED } from "./event-constants";
+/**
+ * Defines the `mixed` selection mode - any combination of vertices and edges is supported.
+ * @group Model
+ * @constant
+ */
+export declare const SELECTION_MODE_MIXED = "mixed";
+/**
+ * Defines the `isolated` selection mode - either a set of vertices, or a set of edges, but not both at the same time.
+ * @group Model
+ * @constant
+ */
+export declare const SELECTION_MODE_ISOLATED = "isolated";
+/**
+ * Defines the `nodesOnly` selection mode - only Node objects
+ * @group Model
+ * @constant
+ */
+export declare const SELECTION_MODE_NODES_ONLY = "nodesOnly";
+/**
+ * Defines the `groupsOnly` selection mode - only Group objects
+ * @group Model
+ * @constant
+ */
+export declare const SELECTION_MODE_GROUPS_ONLY = "groupsOnly";
+/**
+ * Defines the `edgesOnly` selection mode - only Edge objects
+ * @group Model
+ * @constant
+ */
+export declare const SELECTION_MODE_EDGES_ONLY = "edgesOnly";
+/**
+ * Possible modes for a Selection.
+ *
+ * @group Model
+ */
+export type SelectionMode = typeof SELECTION_MODE_ISOLATED | typeof SELECTION_MODE_EDGES_ONLY | typeof SELECTION_MODE_NODES_ONLY | typeof SELECTION_MODE_GROUPS_ONLY | typeof SELECTION_MODE_MIXED;
+/**
+ * Options for the behaviour of a selection.
+ * @group Model
+ */
+export interface SelectionOptions {
+    /**
+     * Optional. called after a reload when a `generator` was supplied.
+     */
+    onReload?: Function;
+    /**
+     * Optional. called before the selection is cleared at the beginning of a reload, when a `generator` is supplied.
+     */
+    onBeforeReload?: Function;
+    /**
+     * Optional function to call when the selection is cleared.
+     */
+    onClear?: Function;
+    /**
+     * Defaults to false. If true, and a `generator` is supplied,
+     */
+    autoFill?: boolean;
+    /**
+     * Optional function that can be called to fill the selection. You'd use this when you are rendering individual selections and you need to be able to refresh the whole view based on some change in the data model.
+     */
+    generator?: Function;
+    /**
+     * If true, the selection will not populate itself as soon as it is constructed. Otherwise, and this is the default behaviour, it will.
+     */
+    lazy?: boolean;
+    /**
+     * Defaults to SelectionModes.mixed, meaning any combination of nodes, groups and edges may be present in the selection at a given point in time.
+     */
+    mode?: SelectionMode;
+}
+/**
+ * Events that a Selection can fire.
+ */
+export type SELECTION_EVENTS = typeof EVENT_EDGE_UPDATED | typeof EVENT_DATA_LOAD_END | typeof EVENT_DATA_LOAD_START | typeof EVENT_NODE_UPDATED | typeof EVENT_GRAPH_CLEAR_START | typeof EVENT_GROUP_UPDATED | typeof EVENT_PORT_UPDATED | typeof EVENT_EDGE_TARGET_CHANGED | typeof EVENT_EDGE_SOURCE_CHANGED | typeof EVENT_EDGE_REMOVED | typeof EVENT_EDGE_ADDED | typeof EVENT_GROUP_REMOVED | typeof EVENT_NODE_REMOVED | typeof EVENT_GROUP_ADDED | typeof EVENT_NODE_ADDED;
+/**
+ * A selection is a group of vertices and edges, upon which you can perform bulk operations.
+ * @group Model
+ */
+export declare class VisuallyJsSelection extends OptimisticEventGenerator implements DataSource {
+    instance: VisuallyJsModel;
+    static DISCARD_EXISTING: string;
+    static DISCARD_NEW: string;
+    private _maxNodes;
+    private _maxEdges;
+    private _maxGroups;
+    _nodes: Array<Node>;
+    _groups: Array<Group>;
+    _edges: Array<Edge>;
+    capacityPolicy: string;
+    generator: Function;
+    onReload: Function;
+    onBeforeReload: Function;
+    onClear: Function;
+    private autoFill;
+    private _$_objMap;
+    private _mode;
+    private _loading;
+    edgeFactory: ObjectFactory;
+    /**
+     * Returns whether or not the selection has any nodes, edges or groups.
+     */
+    isEmpty(): boolean;
+    private _getList;
+    /**
+     * Sets the selection's current mode, flushing any objects which do not match the given mode. If you switch to `SELECTION_MODE_ISOLATED` the entire selection is cleared, because it does not know what single supported type should be until something is subsequently added.
+     * @param mode
+     */
+    setMode(mode: SelectionMode): void;
+    private _pushToList;
+    private _fireListEvent;
+    constructor(instance: VisuallyJsModel, params?: SelectionOptions);
+    private _addOne;
+    private _modePermitsAddition;
+    private _removeOne;
+    private _toggle;
+    private _makeSenseOf;
+    /**
+     * Removes the given object from the selection. May take many forms - a Group, Group Id, Node, Node Id, or Edge, or a list of these, or a Path.
+     * @param obj Object(s) to remove.
+     */
+    remove(obj: string | Array<string> | Base | Array<Base> | Path | VisuallyJsSelection, evtPipe?: (b: Base, append: boolean) => any): any[];
+    /**
+     * Appends the given object to the selection. May take many forms - a Group, Group Id, Node, Node Id, or Edge, or a list of these, or a Path.
+     * @param obj Object(s) to add.
+     */
+    append(obj: string | Array<string> | Base | Array<Base> | Path | VisuallyJsSelection, evtPipe?: (b: Base, append: boolean) => any): any[];
+    /**
+     * Toggles the given object's membership in the current selection. `obj` may take many forms - a Group, Group Id, Node, Node Id, or Edge, or a list of these, or a Path. If `obj` is a Path, then the individual members of the Path are toggled independently.
+     * @param obj Object(s) to add.
+     */
+    toggle(obj: string | Array<string> | Base | Array<Base> | Path | VisuallyJsSelection, evtPipe?: (b: Base, append: boolean) => any): any[];
+    /**
+     * Sets the maximum number of nodes the selection can hold. The action taken when appending a node that would take the selection above its limit depends on the current `capacityPolicy`, which can be either Selection.DISCARD_EXISTING (the default) or Selection.DISCARD_NEW.
+     * @param _maxNodes
+     */
+    setMaxNodes(_maxNodes: number): void;
+    /**
+     * Sets the maximum number of groups the selection can hold. The action taken when appending a group that would take the selection above its limit depends on the current `capacityPolicy`, which can be either Selection.DISCARD_EXISTING (the default) or Selection.DISCARD_NEW.
+     * @param _maxGroups
+     */
+    setMaxGroups(_maxGroups: number): void;
+    /**
+     * Sets the maximum number of edges the selection can hold. The action taken when appending an edge that would take the selection above its limit depends on the current `capacityPolicy`, which can be either Selection.DISCARD_EXISTING (the default) or Selection.DISCARD_NEW.
+     * @param _maxEdges
+     */
+    setMaxEdges(_maxEdges: number): void;
+    /**
+     * Sets the action taken when appending an edge or node that would take the selection above its limit for that given type. One of `Selection.DISCARD_EXISTING` (which removes the 0th entry from the list before insertion of the new value) or `Selection.DISCARD_NEW`.
+     * @param policy One of `Selection.DISCARD_EXISTING` (which removes the 0th entry from the list before insertion of the new value) or `Selection.DISCARD_NEW`.
+     */
+    setCapacityPolicy(policy: string): void;
+    private _clearEdges;
+    private _clearNodes;
+    private _clearGroups;
+    private _clearVertices;
+    private _clearAll;
+    /**
+     * Clears the selection. Does not fire individual deselect events.
+     * @param doNotFireEvent
+     */
+    clear(doNotFireEvent?: boolean): void;
+    private _filterEdgeList;
+    /**
+     * Reloads the content of this Selection, if a `generator` was supplied to the constructor. Otherwise does nothing. A data load start event is fired first, followed by a call to the generator to repopulate, and then a data load end event is fired.  So calling this method on a Selection that you are rendering to a UI will cause the UI to repaint itself.
+     */
+    reload(): void;
+    /**
+     * Iterates the objects of the given type in the selection, calling the supplied callback for each item. The callback's signature should be `function(index, item)`. If you don't supply `type`, the default of "Node" will be used.
+     * @param  fn Function to call with each item.
+     * @param type Type of object to iterate. Defaults to Node.objectType.
+     * @internal
+     */
+    private _each;
+    /**
+     * Iterates the Nodes in the selection, calling the supplied callback for each item. The callback's signature should be `function(index, item)`.
+     * @param fn Function to call with each item.
+     */
+    eachNode(fn: (idx: number, n: Node) => any): void;
+    /**
+     * Iterates the Groups in the selection, calling the supplied callback for each item. The callback's signature should be `function(index, item)`.
+     * @param fn Function to call with each item.
+     */
+    eachGroup(fn: (idx: number, g: Group) => any): void;
+    /**
+     * Iterates the Nodes and the Groups in the selection, calling the supplied callback for each item. The callback's signature should be `function(index, item)`.
+     * @param fn Function to call with each item.
+     */
+    eachVertex(fn: (idx: number, v: Vertex) => any): void;
+    /**
+     * Iterates the Edges in the selection, calling the supplied callback for each item. The callback's signature should be `function(index, item)`.
+     * @param fn Function to call with each item.
+     */
+    eachEdge(fn: (idx: number, e: Edge) => any): void;
+    /**
+     * Get the current number of Nodes in the selection.
+     */
+    getNodeCount(): number;
+    /**
+     * Gets the node at the given index.
+     * @param idx Index of the Node to retrieve. Will return null if index out of range.
+     * @returns A Node, or null.
+     */
+    getNodeAt(idx: number): Node;
+    /**
+     * Gets all the Nodes in the Selection.
+     */
+    getNodes(): Array<Node>;
+    /**
+     * Gets the Node with the given ID, if it is in the current selection
+     * @param id ID of the Node to retrieve
+     */
+    getNode(id: string): Node;
+    /**
+     * Gets the Group at the given index. Will return null if index out of range.
+     * @param idx Index of the Group to retrieve. Will return null if index out of range.
+     * @returns A Group, or null.
+     */
+    getGroupAt(idx: number): Group;
+    /**
+     * Gets all the Groups in the Selection.
+     */
+    getGroups(): Array<Group>;
+    /**
+     * Gets the Group with the given ID, if it is in the selection.
+     * @param id ID of the Group to retrieve
+     */
+    getGroup(id: string): Group;
+    /**
+     * Get the current number of Groups in the selection.
+     */
+    getGroupCount(): number;
+    /**
+     * Gets all the nodes, edges and groups.
+     */
+    getAll(): Array<Node | Group | Edge>;
+    /**
+     * Gets all Edges for the given Node or Group.
+     * @param node The Node to get Edges for.
+     * @param filter Optional filter for edges.
+     * @returns An array of Edges, which may be empty. Never null.
+     */
+    getAllEdgesFor(node: Vertex, filter?: (e: Edge) => boolean): Array<Edge>;
+    /**
+     * Gets all source Edges for the given Node or Group.
+     * @param v The Node/Group to get source Edges for.
+     * @returns An array of Edges, which may be empty. Never null.
+     */
+    getSourceEdgesFor(v: Node | Group): Array<Edge>;
+    /**
+     * Get the current number of Edges in the selection.
+     */
+    getEdgeCount(): number;
+    getAllEdges(): Array<Edge>;
+    /**
+     * Gets the Edge at the given index.
+     * @param idx Index of the Edge to retrieve.
+     * @returns Edge at the given index, null if nothing found at that index.
+     */
+    getEdgeAt(idx: number): Edge;
+    /**
+     * Gets all the edges in the selection
+     * @returns All the edges in the selection, perhaps an empty list. Never null.
+     */
+    getEdges(): Array<Edge>;
+    /**
+     * @internal
+     * @param groupData
+     */
+    getGroupType(groupData: Record<string, any>): string;
+    /**
+     * @internal
+     * @param nodeData
+     */
+    getNodeType(nodeData: Record<string, any>): string;
+    /**
+     * @internal
+     */
+    getModel(): DataModel;
+    /**
+     * @internal
+     */
+    getGraph(): Graph;
+    /**
+     * @internal
+     * @param node
+     */
+    getNodeId(node: Record<string, any>): string;
+    /**
+     * @internal
+     * @param group
+     */
+    getGroupId(group: Record<string, any>): string;
+    /**
+     * @internal
+     * @param port
+     */
+    getPortType(port: Record<string, any>): string;
+    /**
+     * @internal
+     * @param node
+     * @param data
+     */
+    addPort(node: string | Node, data: Record<string, any>): Port;
+    /**
+     * @internal
+     * @param port
+     */
+    getPortId(port: Record<string, any>): string;
+    /**
+     * @internal
+     * @param edgeId
+     */
+    getEdge(edgeId: string): Edge;
+    /**
+     * @internal
+     * @param edgeData
+     */
+    getEdgeType(edgeData: Record<string, any>): string;
+    /**
+     * Returns the vertex with the given id, if it is in the selection.
+     * @param id
+     * @internal
+     */
+    getVertex(id: string): Vertex;
+    /**
+     * Returns whether or not the vertex (node/group) with the given id is in the selection.
+     * @param id
+     */
+    containsVertex(id: string): boolean;
+    /**
+     * @internal
+     * @param obj
+     */
+    getObjectInfo<T>(obj: any): ObjectInfo<T>;
+    /**
+     * @internal
+     * @param source
+     * @param target
+     * @param data
+     * @param userInstigated
+     */
+    beforeConnect(source: Vertex, target: Vertex, data?: Record<string, any>, userInstigated?: boolean): any;
+    /**
+     * @internal
+     * @param source
+     * @param target
+     * @param edge
+     */
+    beforeMoveConnection(source: Vertex, target: Vertex, edge: Edge): any;
+    /**
+     * @internal
+     * @param source
+     * @param type
+     */
+    beforeStartConnect(source: Vertex, type: string): any;
+    /**
+     * @internal
+     * @param source
+     * @param target
+     * @param edge
+     */
+    beforeDetach(source: Vertex, target: Vertex, edge: Edge): any;
+    /**
+     * @internal
+     * @param source
+     * @param edge
+     */
+    beforeStartDetach(source: Vertex, edge: Edge): any;
+    /**
+     * @internal
+     */
+    get debugEnabled(): boolean;
+    private _createSelection;
+    /**
+     * Filter the selection and return a new selection with the filtered contents.
+     * @param spec
+     * @param includePartials
+     */
+    filter(spec: any, includePartials?: boolean): VisuallyJsSelection;
+    getAncestors(vertex: Node | Group): Array<Group>;
+    getDescendants(vertex: Group): Array<Node | Group>;
+    getType(obj: Base): string;
+    isAncestor(focus: Node | Group, possibleAncestor: Group): boolean;
+    isDescendantGroup(possibleDescendant: Group, ancestor: Group): boolean;
+    resolveFullId(b: Base): string;
+}

package/types/core/templates/abstract-entry.d.ts

@@ -0,0 +1,19 @@
+import { Recado } from "./core";
+import { Binding, CompiledBinding } from "./parser";
+/**
+ * @internal
+ */
+export declare abstract class AbstractEntry {
+    instance: Recado;
+    abstract type: string;
+    tag: string;
+    remove: boolean;
+    uuid: string;
+    children: Array<AbstractEntry>;
+    elements: Array<any>;
+    bindings: Record<string, Binding>;
+    context: string;
+    compiledBindings: Record<string, CompiledBinding>;
+    protected constructor(instance: Recado);
+    protected _processBindings(bindings: Record<string, Binding>): void;
+}

package/types/core/templates/comment-entry.d.ts

@@ -0,0 +1,11 @@
+import { AbstractEntry } from './abstract-entry';
+import { Recado } from "./core";
+/**
+ * @internal
+ */
+export declare class CommentEntry extends AbstractEntry {
+    static type: string;
+    type: string;
+    comment: string;
+    constructor(comment: string, instance: Recado);
+}

package/types/core/templates/core.d.ts

@@ -0,0 +1,162 @@
+import { CommentFacade, ElementFacade, FragmentFacade, RecadoOptions, RecadoValueFormatter, TextNodeFacade } from "./defs";
+import { TemplateResolver } from "./defs";
+import { CompiledBinding } from "./parser";
+import { AbstractEntry } from './abstract-entry';
+import { CustomTag, CustomTagOptions } from "./custom-tag";
+import { IRootExecution, UpdateResult } from "./executions";
+/**
+ * @internal
+ */
+export interface BindingResult {
+    id: string;
+    binding: CompiledBinding;
+    results: Array<{
+        source: string;
+        result: any;
+    }>;
+    originalValue: any;
+    type: "attribute" | "text";
+    once?: boolean;
+}
+/**
+ * @internal
+ */
+export declare abstract class Recado {
+    templateResolver: TemplateResolver;
+    defaultTemplate: string;
+    defaultNamespace: string;
+    macros: Record<string, (d: Record<string, any>, context: Record<string, any>, ...args: Array<string>) => string>;
+    entries: Record<string, AbstractEntry>;
+    customTags: Record<string, CustomTag>;
+    formatter: RecadoValueFormatter;
+    private _cache;
+    private _templateCache;
+    openRe: RegExp;
+    closeRe: RegExp;
+    openCloseRe: RegExp;
+    tokenizerRe: RegExp;
+    commentRe: RegExp;
+    attributesRe: RegExp;
+    private readonly _templates;
+    abstract _getDefaultTemplateResolver(): TemplateResolver;
+    constructor(options: RecadoOptions);
+    /**
+     * Lookup a template by ID.
+     * @param id
+     * @internal
+     */
+    resolveTemplate(id: string): string;
+    setAttribute(el: any, a: string, v: string): void;
+    clearCache(): void;
+    namespaceHandlers: Record<string, (tag: string) => ElementFacade>;
+    namespaces: Record<string, string>;
+    /**
+     * Create a Fragment for the current environment
+     */
+    abstract cf(): FragmentFacade;
+    /**
+     * Create a text node for the current environment
+     * @param value
+     */
+    abstract ctn(value: string): TextNodeFacade;
+    /**
+     * Create an element for the current environment
+     * @param tag
+     */
+    abstract ce(tag: string): ElementFacade;
+    /**
+     * Create a comment element. Used as placeholders for loop/control structures.
+     * @param content
+     */
+    abstract cc(content: string): CommentFacade;
+    abstract removeElement(e: ElementFacade): void;
+    abstract removeTextNode(e: TextNodeFacade): void;
+    parseAttributes(el: string): string[];
+    /**
+     * @internal
+     * @param resolver
+     * @param forceReload
+     */
+    _wrapCache(resolver: TemplateResolver, forceReload?: boolean): TemplateResolver;
+    getTemplate(id: string): Array<AbstractEntry>;
+    /**
+     * Add a template. The template is not parsed until such time as someone asks for it.
+     * @param id
+     * @param content
+     * @internal
+     */
+    addTemplate(id: string, content: string): void;
+    template(id: string, data: Record<string, any>, templateResolver?: TemplateResolver, forceReload?: boolean, context?: Record<string, any>): FragmentFacade;
+    mounted(fragment: FragmentFacade): void;
+    /**
+     * Resolve, parse and then cache the template with the given id. If the template has already been resolved and parsed,
+     * return the parsed value, unless `forceReload` is set to true.
+     * @param templateId
+     * @param templateResolver
+     * @param forceReload
+     */
+    parseAndCache(templateId: string, templateResolver?: TemplateResolver, forceReload?: boolean): Array<AbstractEntry>;
+    /**
+     * Get, or set, a value from/to an object.
+     * @param inObj Object to operate on
+     * @param path Path to the value to get/set
+     * @param value If null, this method gets a value. Otherwise, this method sets a value.
+     */
+    data(inObj: Record<string, any>, path: string, value?: any): any;
+    each(l: any, fn: Function, loopUuid: string, ctx: string, key: string): void;
+    lookupValueInDataOrContext(templateData: Record<string, any>, context: Record<string, any>, key: string): any;
+    update<T>(el: any, templateData: Record<string, any>, context?: Record<string, any>): UpdateResult<T>;
+    onUpdate(el: any, fn: Function): void;
+    private _updateExecution;
+    /**
+     * Removes the given element from this Recado instance, and optionally removes it from the DOM too.
+     * @param el Element to remove.
+     * @param removeFromDOM Whether or not to also remove from the DOM.
+     * @internal
+     */
+    remove(el: any, removeFromDOM?: boolean): void;
+    /**
+     * Register a custom tag.
+     * @param tagName
+     * @param handlers
+     *
+     */
+    registerTag(tagName: string, handlers: CustomTagOptions): void;
+    /**
+     * Parse the given template into an AST.
+     * @param str
+     * @param templateResolver
+     * @param extraProperties
+     * @param parseIdStack
+     * @internal
+     */
+    parse(str: string, templateResolver?: TemplateResolver, extraProperties?: any, parseIdStack?: Array<string>): Array<AbstractEntry>;
+    /**
+     * Run the given macro, if found.
+     * @param expansionId
+     * @param data
+     * @param context
+     * @internal
+     */
+    _expand(expansionId: string, data: Record<string, any>, context: Record<string, any>): string;
+    /**
+     * Render the given AST using the given data.
+     * @param p
+     * @param templateData
+     * @param templateResolver
+     */
+    render(p: Array<AbstractEntry>, templateData?: Record<string, any>, templateResolver?: TemplateResolver, context?: Record<string, any>, defaultNamespace?: string): IRootExecution;
+}
+/**
+ * Formats a number according to a specifier string.
+ * d       integer, locale separator
+ * ,d      integer, comma separator
+ * 'd      integer, space separator
+ * f       float, any number of decimals, locale separator
+ * ,f      float, any number of decimals, comma separator
+ * 'f      float, any number of decimals, space separator
+ * .3f     float, 3 decimal places, locale separator
+ * ,.3f    float, 3 decimal places, comma separator
+ * '.3f    float, 3 decimal places, space separator
+ */
+export declare function lightweightPrintfFormatter(value: number | string, format: string): string;

package/types/core/templates/custom-tag.d.ts

@@ -0,0 +1,74 @@
+import { Recado } from "./core";
+import { AbstractEntry } from './abstract-entry';
+import { ElementFacade } from "./defs";
+import { ObjectData } from "../model/graph";
+/** @internal */
+export type MountFunction = (el: ElementFacade, data: any, instance: Recado, parent: ElementFacade, context?: Record<string, any>) => void;
+/**
+ * Options for a custom tag
+ * @group Components
+ * @category Templating
+ */
+export interface CustomTagOptions {
+    /**
+     * Template to use to render the tag
+     */
+    template: string;
+    /**
+     * Callback invoked when the tag has first been rendered.
+     * @param el
+     * @param data
+     * @param instance
+     * @param parent
+     * @param context
+     */
+    rendered?: (el: any, data: any, instance: Recado, parent: ElementFacade, context?: Record<string, any>) => void;
+    /**
+     * Callback invoked after the tag has been re-rendered during an update.
+     * @param el
+     * @param data
+     * @param instance
+     */
+    updated?: (el: any, data: any, instance: Recado) => void;
+    /**
+     * Callback invoked when the element this tag produced has been mounted. In the DOM this means that it is now in the Document, but this class does not know directly of the existence of the DOM.
+     * @param el
+     * @param data
+     * @param instance
+     * @param parent
+     * @param context
+     */
+    mounted?: (el: any, data: any, instance: Recado, parent: ElementFacade, context?: Record<string, any>) => void;
+    fragments?: Record<string, Record<string, string>>;
+    defaultableFragmentKeys?: Array<string>;
+    /**
+     * Optional data decorator which will be invoked prior to a render and which can return additional data to use to render.  The return value should be extra data: you should not manipulate the contents of the incoming `data` member. VisuallyJs will merge any data you return from this method into the current data prior to rendering.
+     * @param data Data to use to decorate.
+     */
+    decorator?: (data: ObjectData, context?: Record<string, any>) => ObjectData | null;
+    defaultNamespace?: string;
+}
+/**
+ * @internal
+ */
+export declare class CustomTag {
+    instance: Recado;
+    tagName: string;
+    options: CustomTagOptions;
+    id: string;
+    template: string;
+    rendered: (el: ElementFacade, data: any, instance: Recado, parent: ElementFacade, context?: Record<string, any>) => void;
+    updated: (el: ElementFacade, data: any, instance: Recado) => void;
+    fragments: Record<string, Record<string, Array<AbstractEntry>>>;
+    mounted: (el: any, data: any, instance: Recado, parent: ElementFacade, context?: Record<string, any>) => void;
+    defaultableFragmentKeys: Array<string>;
+    private fragmentKeys;
+    private parsedTemplates;
+    defaultNamespace: string;
+    decorator: (data: ObjectData, context?: Record<string, any>) => ObjectData | null;
+    constructor(instance: Recado, tagName: string, options: CustomTagOptions);
+    private _parseDefault;
+    private extractTemplateData;
+    getAST(templateData: Record<string, any>): AbstractEntry[];
+    private _replaceAST;
+}