terminusdb 12.0.2

package/dist/typescript/lib/viewer/woqlGraph.d.ts

@@ -0,0 +1,26 @@
+export = WOQLGraph;
+declare function WOQLGraph(client: any, config: any): void;
+declare class WOQLGraph {
+    constructor(client: any, config: any);
+    client: any;
+    config: any;
+    nodes: any[];
+    edges: any[];
+    options(config: any): this;
+    setResult(result: any): void;
+    result: any;
+    calculateVariableTypes(): void;
+    extractFromBinding(row: any, rownum: any): void;
+    addAdornedEdge(source: any, target: any, ks: any, kt: any, row: any): void;
+    addAdornedNode(nid: any, k: any, row: any): void;
+    getLiteralOwner(nodes: any, v: any, row: any): any;
+    createEdgesFromIDs(nodes: any, row: any): void;
+    getEdges(): any[];
+    combineNodes(nodes: any): any[];
+    combineEdges(edges: any): any[];
+    nodes_referenced_by_edges: any[];
+    getNodes(): any[];
+    includeNode(v: any, row: any): boolean;
+    includeLiteralNode(variableName: any, row: any): boolean;
+    includeRow(row: any, num: any): boolean;
+}

package/dist/typescript/lib/viewer/woqlPaging.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/typescript/lib/viewer/woqlResult.d.ts

@@ -0,0 +1,128 @@
+export = WOQLResult;
+/**
+ * @typedef {Object} WOQLQuery
+ */
+/**
+ * @module WOQLResult
+ * @license Apache Version 2
+ * Object representing the result of a WOQL Query
+ * @param {object} results result JSON object as returned by WOQL query
+ * @param {WOQLQuery} query the query object that generated the result
+ * @param {object} [config] optional result configuration options object
+ * [config.no_compress] by default all URLs are compressed where possible (v:X rather than http://.../variable/x) set to true to return non-compressed values
+ * [config.context] specify the JSON-LD context to use for compressing results - by default
+ * the query context will be used
+ */
+declare function WOQLResult(results: object, query: WOQLQuery, config?: object): void;
+declare class WOQLResult {
+    /**
+     * @typedef {Object} WOQLQuery
+     */
+    /**
+     * @module WOQLResult
+     * @license Apache Version 2
+     * Object representing the result of a WOQL Query
+     * @param {object} results result JSON object as returned by WOQL query
+     * @param {WOQLQuery} query the query object that generated the result
+     * @param {object} [config] optional result configuration options object
+     * [config.no_compress] by default all URLs are compressed where possible (v:X rather than http://.../variable/x) set to true to return non-compressed values
+     * [config.context] specify the JSON-LD context to use for compressing results - by default
+     * the query context will be used
+     */
+    constructor(results: object, query: WOQLQuery, config?: object);
+    bindings: any;
+    insert_count: any;
+    delete_count: any;
+    transaction_retry_count: any;
+    /**
+       * @type {array | boolean}
+       */
+    variable_names: any[] | boolean;
+    query: any;
+    cursor: number;
+    formatter(context: any): any[];
+    /**
+     * @param {object} [context] optional context to use for compression -
+     * if ommitted query context is used
+     * @returns {WOQLResult}
+     */
+    compress(context?: object): WOQLResult;
+    /**
+     * Returns true if there are any results
+     * @returns {boolean}
+     */
+    hasBindings(): boolean;
+    /**
+     * Returns true if there are any results
+     * @returns {boolean}
+     */
+    hasUpdates(): boolean;
+    /**
+     * Returns original array of bindings returned by API
+     * @returns {array} the data result
+     */
+    getBindings(): any[];
+    /**
+     * Returns original array of bindings returned by API
+     * @returns {array} the data result
+     */
+    rows(): any[];
+    /**
+     * Returns list of variables returned in bindings from API
+     * @returns {array|boolean}
+     */
+    getVariableList(): any[] | boolean;
+    /**
+     * Number of rows in bound results
+     * @returns {number}
+     */
+    count(): number;
+    /**
+     * Number of reported inserts
+     * @returns {number}
+     */
+    inserts(): number;
+    /**
+     * Number of reported inserts
+     * @returns {number}
+     */
+    deletes(): number;
+    /**
+     * Get the first object record from the result set
+     * @returns {object}
+     */
+    first(): object;
+    /**
+     * Get the last object record from the result set
+     * @returns {object}
+     */
+    last(): object;
+    /**
+     * @returns {object}
+     */
+    next(): object;
+    /**
+     * @returns {object}
+     */
+    prev(): object;
+    /**
+     * Normally sorting of results is the job of the query - this is just in case you
+     * want to resort results according to some key (variable)
+     * @param {string} key
+     * @param {string} asc_or_desc
+     * @returns {WOQLResult}
+     */
+    sort(key: string, asc_or_desc: string): WOQLResult;
+    /**
+     * Compares results a, b according to "asc" or "desc" order
+     * @param {object} a
+     * @param {object} b
+     * @param {string} [asc_or_desc]
+     * @returns {number}
+     */
+    compareValues(a: object, b: object, asc_or_desc?: string): number;
+}
+declare namespace WOQLResult {
+    export { WOQLQuery };
+}
+type WOQLQuery = any;

package/dist/typescript/lib/viewer/woqlRule.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @file WOQL Rules
+ * @license Apache Version 2
+ * WOQL Rules support pattern matching on results of WOQL Queries
+ */
+export function WOQLRule(): void;
+export class WOQLRule {
+    pattern: WOQLPattern;
+    /**
+     * Specifies that the rule only applies to specific variables returned by the WOQL query
+     * @param {Array<string>} vars - array of strings, each a variable name, variable prefixes
+     * ("v:") are added automatically if absent
+     */
+    setVariables(vars: Array<string>): this;
+    current_variable: any;
+    /**
+     * Shorthand to the above using spread operator
+     */
+    vars(...varlist: any[]): this;
+    /**
+     * Specifies that the rule applies to a specific variable, variable prefix ("v:")
+     * is added automatically if absent
+     */
+    v(v: any): any;
+    /**
+     * Specifies that the rule applies to a specific edge, a source -> target pair of variables
+     */
+    edge(source: any, target: any): this;
+    /**
+     * Specifies that the rule applies to a specific edge, a source -> target pair of variables
+     */
+    rownum(rownum: any): any;
+    /**
+     * Specifies that the value of a variable must be one of the values contained in the list
+     * @param {...(string|number)} list - parameters are any atomic value (string | number) -
+     * the rule will match only cells that have one of these values
+     */
+    in(...list: (string | number)[]): this;
+    /**
+     * Specifies a filter function to apply to each element - only those values that
+     * return true when this filter is invoked will be matched
+     * @param {function} tester - test function that will be used to filter values
+     */
+    filter(tester: Function): this;
+    matchRow(rules: any, row: any, rownum: any, action: any): any[];
+    matchCell(rules: any, row: any, key: any, rownum: any, action: any): any[];
+    /**
+     *
+     * @param {array} rules
+     * @param {string} key - column name
+     * @param {string} ruleName - the rule name like header, width etc...
+     * @returns {array}
+     */
+    matchColumn(rules: any[], key: string, ruleName: string): any[];
+    matchNode(rules: any, row: any, key: any, nid: any, action: any): any[];
+    matchPair(rules: any, row: any, keya: any, keyb: any, action: any): any[];
+    matchEdge: any;
+}
+/**
+ * Object to encapsulate the matching of woql result patterns - inherits from TerminusRule
+ * @param {Object} pattern
+ */
+export function WOQLPattern(pattern: any): void;
+export class WOQLPattern {
+    /**
+     * Object to encapsulate the matching of woql result patterns - inherits from TerminusRule
+     * @param {Object} pattern
+     */
+    constructor(pattern: any);
+    prettyPrint(): string;
+    /**
+     * @param {String|Object} data
+     * @param {string|Array<string>} [key] - a variable or an array of two variables
+     * (in the case of edge scope) which constitutes the key being tested
+     * @param {String} [scope] - the scope in which the test is being carried out (row, column, cell)
+     */
+    matchRow(row: any, rownum: any): boolean;
+    matchCell(row: any, key: any, rownum: any): boolean;
+    matchNode(row: any, key: any): boolean;
+    matchColumn(key: any): boolean;
+    matchPair(row: any, keya: any, keyb: any): boolean;
+    testVariableConstraints(row: any): boolean;
+    testVariableConstraint(name: any, val: any): boolean;
+    setPattern(pattern: any): void;
+    json(): {
+        scope: any;
+        value: any;
+        rownum: any;
+        variables: any;
+        literal: any;
+        type: any;
+        constraints: any;
+        source: any;
+        target: any;
+    };
+}

package/dist/typescript/lib/viewer/woqlStream.d.ts

@@ -0,0 +1,31 @@
+export = WOQLStream;
+/**
+ * @typedef {Object} WOQLClient
+ */
+/**
+ * @param {WOQLClient} client
+ * @param {WOQLStreamConfig} config
+ * @returns {WOQLStream}
+ */
+declare function WOQLStream(client: WOQLClient, config: WOQLStreamConfig): WOQLStream;
+declare class WOQLStream {
+    /**
+     * @typedef {Object} WOQLClient
+     */
+    /**
+     * @param {WOQLClient} client
+     * @param {WOQLStreamConfig} config
+     * @returns {WOQLStream}
+     */
+    constructor(client: WOQLClient, config: WOQLStreamConfig);
+    client: any;
+    config: WOQLStreamConfig;
+    options(config: any): this;
+    setResult(wqrs: any): void;
+    result: any;
+}
+declare namespace WOQLStream {
+    export { WOQLClient };
+}
+import WOQLStreamConfig = require("./streamConfig");
+type WOQLClient = any;

package/dist/typescript/lib/viewer/woqlTable.d.ts

@@ -0,0 +1,102 @@
+export = WOQLTable;
+/**
+ * @module WOQLTable
+ * @license Apache Version 2
+ * @param {WOQLClient} [client] we need an client if we do a server side pagination,sorting etc...
+ * @param {WOQLTableConfig} [config]
+ * @returns {WOQLTable}
+ */
+declare function WOQLTable(client?: WOQLClient, config?: WOQLTableConfig): WOQLTable;
+declare class WOQLTable {
+    /**
+     * @module WOQLTable
+     * @license Apache Version 2
+     * @param {WOQLClient} [client] we need an client if we do a server side pagination,sorting etc...
+     * @param {WOQLTableConfig} [config]
+     * @returns {WOQLTable}
+     */
+    constructor(client?: WOQLClient, config?: WOQLTableConfig);
+    client: WOQLClient;
+    config: WOQLTableConfig;
+    /**
+     * set the WOQLTableConfig for this table
+     * @param {WOQLTableConfig} config
+     * @returns {WOQLTable}
+     */
+    options(config: WOQLTableConfig): WOQLTable;
+    /**
+     * Set the query result using the WOQLResult object
+     * @param {WOQLResult} result - the WOQLResult object
+     * @returns {WOQLTable}
+     */
+    setResult(result: WOQLResult): WOQLTable;
+    result: WOQLResult;
+    /**
+     * @returns {number} the total result
+     */
+    count(): number;
+    /**
+     * Get the first object record from the result set
+     * @returns {object}
+     */
+    first(): object;
+    /**
+     * Get the preview object record from the result set
+     * @returns {object}
+     */
+    prev(): object;
+    /**
+     * Get the next object record from the result set
+     * @returns {object}
+     */
+    next(): object;
+    /**
+     * @returns {boolean}
+     */
+    canAdvancePage(): boolean;
+    canChangePage(): boolean;
+    canRetreatPage(): boolean;
+    getPageSize(): any;
+    setPage(l: any): any;
+    getPage(): any;
+    setPageSize(l: any): any;
+    nextPage(): any;
+    firstPage(): any;
+    previousPage(): any;
+    getColumnsToRender(): any;
+    getColumnHeaderContents(colid: any): any;
+    hidden(col: any): any;
+    /**
+     * Called when you want to change the query associated with the table.
+     */
+    update(nquery: any): any;
+    hasDefinedEvent(row: any, key: any, scope: any, action: any, rownum: any): boolean;
+    getDefinedEvent(row: any, key: any, scope: any, action: any, rownum: any): any;
+    getRowClick(row: any): any;
+    uncompressed(row: any, col: any): any;
+    getCellClick(row: any, col: any): any;
+    getRowHover(row: any): any;
+    getCellHover(row: any, key: any): any;
+    getColumnOrder(): any;
+    bindings(): any;
+    getColumnFilter(colid: any): any;
+    getColumnDimensions(key: any): {
+        width: any;
+        maxWidth: any;
+        minWidth: any;
+    };
+    hasColumnOrder: any;
+    hasCellClick: any;
+    hasRowClick: any;
+    hasCellHover: any;
+    hasRowHover: any;
+    getRenderer(key: any, row: any, rownum: any): any;
+    isSortableColumn(key: any): boolean;
+    isFilterableColumn(key: any): boolean;
+    renderValue(renderer: any, val: any, key: any, row: any): any;
+    getRendererForDatatype(val: any): any;
+    getSpecificRender(key: any, row: any): any;
+}
+import WOQLClient = require("../woqlClient");
+import WOQLTableConfig = require("./tableConfig");
+import WOQLResult = require("./woqlResult");

package/dist/typescript/lib/viewer/woqlView.d.ts

@@ -0,0 +1,49 @@
+import WOQLTableConfig = require("./tableConfig");
+import WOQLChartConfig = require("./chartConfig");
+import WOQLGraphConfig = require("./graphConfig");
+import WOQLChooserConfig = require("./chooserConfig");
+import WOQLStreamConfig = require("./streamConfig");
+import FrameConfig = require("./frameConfig");
+import { WOQLRule } from "./woqlRule";
+import { FrameRule } from "./frameRule";
+export function table(): WOQLTableConfig;
+export function chart(): WOQLChartConfig;
+export function graph(): WOQLGraphConfig;
+export function chooser(): WOQLChooserConfig;
+export function stream(): WOQLStreamConfig;
+export function document(): FrameConfig;
+export function loadConfig(config: any): WOQLChartConfig | WOQLChooserConfig | FrameConfig | WOQLGraphConfig | WOQLStreamConfig | WOQLTableConfig;
+/**
+ * Shorthand functions for accessing the pattern matching capabilities
+ */
+export function rule(type: any): WOQLRule | FrameRule;
+export function pattern(type: any): import("./woqlRule").WOQLPattern | import("./frameRule").FramePattern;
+/**
+ * Called to match an entire row of results is matched by a set of rules
+ * returns array of rules that matched
+ */
+export function matchRow(rules: any, row: any, rownum: any, action: any): any[];
+/**
+ * Called to test whether an entire column of results is matched by a set of rules
+ * returns array of rules that matched
+ */
+export function matchColumn(rules: any, key: any, action: any): any[];
+/**
+ * Called to test whether a specific cell is matched by a set of rules
+ * returns array of rules that matched
+ */
+export function matchCell(rules: any, row: any, key: any, rownum: any, action: any): any[];
+/**
+ * Called to test whether a specific node is matched by a set of rules
+ * returns array of rules that matched
+ */
+export function matchNode(rules: any, row: any, key: any, nid: any, action: any): any[];
+/**
+ * Called to test whether a specific edge (source -> target) is matched by a set of rules
+ * returns array of rules that matched
+ */
+export function matchEdge(rules: any, row: any, keya: any, keyb: any, action: any): any[];
+/**
+ * Called to test whether a specific frame is matched by a set of rules
+ */
+export function matchFrame(rules: any, frame: any, onmatch: any): FrameRule[];