terminusdb 12.0.2

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

@@ -0,0 +1,145 @@
+export type Frame = any;
+/**
+ * @typedef {Object} Frame
+ */
+/**
+ * @file Frame Rule
+ * @license Apache Version 2
+ */
+export function FrameRule(): void;
+export class FrameRule {
+    pattern: FramePattern;
+    /**
+     * Returns an array of rules that match the paased frame
+     * @param {Array<FrameRule>} rules - array of rules to be tested
+     * @param {Frame | object} frame - document frame, object frame, or property frame to be tested
+     * @param {function} [onmatch] - optional function to be called with args (frame, rule)
+     * on each match
+     */
+    testRules(rules: Array<FrameRule>, frame: Frame | object, onmatch?: Function): FrameRule[];
+    /**
+     * Determines whether a given pattern matches a given frame
+     */
+    patternMatchesFrame(pattern: any, frame: any): any;
+    /**
+     * Specifies that only one from among the list of properties will match
+     */
+    property(...prop: any[]): any;
+    /**
+     * Specifies that only one from among the list of frame_types will match
+     * frame_types are: data, oneOf, document, object?
+     */
+    frame_type(...frame_type: any[]): any;
+    /**
+     * Specifies that only one from among the list of labels will match
+     */
+    label(...prop: any[]): any;
+    /**
+     * Specifies that only one from among the list of subject ids will match
+     */
+    subject(...prop: any[]): any;
+    /**
+     * Specifies that only one from among the list of subject classes will match
+     */
+    subjectClass(...prop: any[]): any;
+    /**
+     * Specifies that only one from among the list of range types will match
+     */
+    range(...prop: any[]): any;
+    /**
+     * Specifies that only one from among the list of range types will match
+     */
+    value(...prop: any[]): any;
+    /**
+     * Specifies that only frames of the specified depth will match the rule
+     */
+    depth(depth: any): any;
+    /**
+     * Specifies that only frames of the specified index will match the rule (index is the order of a
+     * value in the property frame)
+     */
+    index(...index: any[]): any;
+    /**
+     * Specifies that only frames with the given statuses will match the rule
+     */
+    status(...status: any[]): any;
+    /**
+     * Specifies that the frame will only match if its parent matches the pattern passed as par
+     */
+    parent(par: any): any;
+    children(...children: any[]): any[] | this;
+}
+/**
+ * @file Frame Pattern
+ * A frame pattern can have the following variables
+ * scope : object, property, data, * - matches a specific part of the frame
+ * label : matches the label of a property
+ * frame_type: object, data, document, id, oneOf
+ * subject: id of the subject
+ * subjectClass: class of the subject
+ * range: type of a property (applies to property and data)
+ * property: property id or list of property ids (parent property if it is an object or data)
+ * value: value of the property
+ * parent: a pattern relating to the parent of this frame
+ * children: patterns for matching on the children of a frame
+ * depth: how deep are we in the document? starts from 0
+ * index: the index of a value in an array
+ * status: updated, error, new, ok,
+ */
+export function FramePattern(): void;
+export class FramePattern {
+    setPattern(pattern: any): void;
+    scope: any;
+    literal: any;
+    type: any;
+    label: any;
+    frame_type: any;
+    subject: any;
+    subjectClass: any;
+    range: any;
+    property: any;
+    value: any;
+    parent: any;
+    children: any[];
+    depth: any;
+    index: any;
+    status: any;
+    json(): {
+        literal: any;
+        type: any;
+        scope: any;
+        value: any;
+        label: any;
+        frame_type: any;
+        subject: any;
+        subjectClass: any;
+        range: any;
+        property: any;
+        parent: any;
+        children: any[];
+        depth: any;
+        index: any;
+        status: any;
+    };
+    checkFrame(frame: any): boolean;
+    prettyPrint(): string;
+    illegalRuleType(rtype: any): boolean;
+    checkSubject(subject: any, frame: any): boolean;
+    checkChildren(rtype: any, frame: any): boolean;
+    checkStatus(rtype: any, frame: any): boolean;
+    checkDepth(rtype: any, frame: any): any;
+    checkParent(rtype: any, frame: any): any;
+    checkIndex(rtype: any, frame: any): boolean;
+    checkProperty(rtype: any, frame: any): boolean;
+    /**
+     * Checks to make sure the frame is among the specified types
+     */
+    checkType(rtype: any, frame: any): boolean;
+    checkLiteral(rtype: any, frame: any): any;
+    checkValue(rtype: any, frame: any): boolean;
+    checkRange(rtype: any, frame: any): boolean;
+    checkSubjectClass(rtype: any, frame: any): boolean;
+    checkFrameType(rtype: any, frame: any): boolean;
+    checkLabel(rtype: any, frame: any): boolean;
+    getRendererType(frame: any): any;
+}

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

@@ -0,0 +1,73 @@
+export = WOQLGraphConfig;
+declare function WOQLGraphConfig(): void;
+declare class WOQLGraphConfig {
+    type: string;
+    create(client: any): WOQLGraph;
+    literals(v: any): any;
+    show_literals: any;
+    source(v: any): any;
+    source_variable: any;
+    fontfamily(v: any): any;
+    fontfam: any;
+    show_force(v: any): any;
+    force: any;
+    fix_nodes(v: any): any;
+    fixed: any;
+    explode_out(v: any): any;
+    explode: any;
+    selected_grows(v: any): any;
+    bigsel: any;
+    /**
+     * no parameter get the graph width or
+     * set the graph width and return the WOQLGraphConfig
+     * @param {size} Number
+     */
+    width(size: any): any;
+    gwidth: any;
+    /**
+     * no parameter get the graph height or
+     * set the graph height and return the WOQLGraphConfig
+     * @param {size} Number
+     */
+    height(size: any): any;
+    gheight: any;
+    /**
+     *
+     * @param  {...any} edges
+     * @returns {any[][]}
+     */
+    edges(...edges: any[]): any[][];
+    show_edges: any[][];
+    edge(source: any, target: any): any;
+    node(...cols: any[]): WOQLGraphRule;
+    loadJSON(config: any, rules: any): void;
+    rules: WOQLGraphRule[];
+    prettyPrint(): string;
+    json(): {
+        graph: {
+            literals: any;
+            source: any;
+            fontfamily: any;
+            show_force: any;
+            fix_nodes: any;
+            explode_out: any;
+            selected_grows: any;
+            width: any;
+            height: any;
+            edges: any[][];
+        };
+        rules: any[];
+    };
+}
+import WOQLGraph = require("./woqlGraph.js");
+declare function WOQLGraphRule(scope: any): void;
+declare class WOQLGraphRule {
+    constructor(scope: any);
+    charge(v: any): any;
+    collisionRadius(v: any): any;
+    arrow(json: any): any;
+    distance(d: any): any;
+    symmetric(d: any): any;
+    weight(w: any): any;
+    prettyPrint(): any;
+}

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

@@ -0,0 +1,212 @@
+export = ObjectFrame;
+/**
+ * @file Javascript Terminus Document Classes
+ * @license Apache Version 2
+ * Helper classes for accessing documents returned by the Terminus DB API programmatically
+ *
+ * @example
+ * let doc = new TerminusDocument(client);
+ *
+ * //These set the objects document property and return promises:
+ *
+ * doc.loadDocument(URL).then(() => console.log(this.document));
+ * doc.loadComplete(URL, CLS).then(() => console.log(this.document))
+ * doc.loadSchema(cls).then(() => console.log(this.document))
+ *
+ * //These just set the object's document property
+ * doc.loadJSON(json_frames, cls) //console.log(this.document)
+ * doc.loadDataFrames(json_frames, cls)
+ * doc.loadClassFrames(json_frames, cls)
+ * @description Represents a frame for programmatic access to object frame,
+ * anywhere within a document
+ * Recursive data structure where this.children contains an indexed array of object frames
+ * and this.dataframes contains a property indexed array of data frames
+ * Every object frame carries a reference to its classframe
+ * This gives us instructions as to how to create new frames according to the schema
+ * After that it's turtles all the way down.
+ * @param cls - ID of the class (URL)
+ * @param classframe - an array of frames representing a class
+ * @param archetypes list of class frames
+ * @param parent parent object
+ * @returns {ObjectFrame}
+ */
+declare function ObjectFrame(cls: any, jsonld: any, classframes: any, parent: any): ObjectFrame;
+declare class ObjectFrame {
+    /**
+     * @file Javascript Terminus Document Classes
+     * @license Apache Version 2
+     * Helper classes for accessing documents returned by the Terminus DB API programmatically
+     *
+     * @example
+     * let doc = new TerminusDocument(client);
+     *
+     * //These set the objects document property and return promises:
+     *
+     * doc.loadDocument(URL).then(() => console.log(this.document));
+     * doc.loadComplete(URL, CLS).then(() => console.log(this.document))
+     * doc.loadSchema(cls).then(() => console.log(this.document))
+     *
+     * //These just set the object's document property
+     * doc.loadJSON(json_frames, cls) //console.log(this.document)
+     * doc.loadDataFrames(json_frames, cls)
+     * doc.loadClassFrames(json_frames, cls)
+     * @description Represents a frame for programmatic access to object frame,
+     * anywhere within a document
+     * Recursive data structure where this.children contains an indexed array of object frames
+     * and this.dataframes contains a property indexed array of data frames
+     * Every object frame carries a reference to its classframe
+     * This gives us instructions as to how to create new frames according to the schema
+     * After that it's turtles all the way down.
+     * @param cls - ID of the class (URL)
+     * @param classframe - an array of frames representing a class
+     * @param archetypes list of class frames
+     * @param parent parent object
+     * @returns {ObjectFrame}
+     */
+    constructor(cls: any, jsonld: any, classframes: any, parent: any);
+    cls: string;
+    originalDocument: any;
+    parent: any;
+    newDoc: boolean;
+    /**
+     * Loads class frames for the object's class - the instructions about how to put an object together
+     */
+    loadClassFrames(classframes: any): this;
+    jsonld_context: any;
+    classframes: {};
+    /**
+     * Does this object have a schema loaded?
+     */
+    hasSchema(): boolean;
+    loadJSONLDDocument(rdoc: any): this;
+    subjid: any;
+    getAsFrame(prop: any, parent: any): any;
+    getAsFrames(prop: any, parent: any): any[];
+    /**
+     * Cleans out object and sets everything empty
+     */
+    empty(): void;
+    properties: {};
+    restrictions: {};
+    reset(prop: any): void;
+    clear(): this;
+    mfilter(rules: any, onmatch: any): this;
+    /**
+     * If a class frame is present, it is returned for the given property
+     * If no class frame is present and an instance frame is passed in the
+     * this enables make it up as you go along editing
+     * second argument a class frame will be created from the instance frame.
+     */
+    getPropertyClassFrame(prop: any, jsonlddoc: any): any;
+    getProperties(type: any): string[];
+    /**
+     * Missing properties are those that are present in the classframe,
+     * but not instantiated in the current object frame
+     * for this to work we need to load the frame with the associated classframe
+     */
+    getMissingPropertyList(): {
+        label: any;
+        value: string;
+    }[];
+    /**
+     * Returns a list of all the classes that can show up in the frame
+     */
+    getPossibleContainedClasses(): any[];
+    getDocumentLinks(): any[];
+    /**
+     * List of properties that are filled in the object
+     */
+    getFilledPropertyList(): {
+        label: any;
+        value: string;
+    }[];
+    fillFromSchema(newid: any): this;
+    originalFrames: any[];
+    clone(newid: any): ObjectFrame;
+    /**
+     * Returns a child frame with a particular id
+     * If the second parameter is included, it will only look in that specific property
+     * Otherwise searches all properties for the child
+     */
+    getChild(childid: any, prop: any): any;
+    addProperty(prop: any, cls: any): false | PropertyFrame;
+    addPropertyValue(prop: any, value: any): any;
+    removeProperty(prop: any): void;
+    removePropertyValue(prop: any, value: any, index: any): void;
+    error(msg: any): void;
+    errors: any[];
+    extract(): any;
+    extractJSONLD(extracts: any): any;
+    subject(): any;
+    get: any;
+    set(val: any): void;
+    isObject(): boolean;
+    isProperty(): boolean;
+    isData(): boolean;
+    isClassChoice(): boolean;
+    subjectClass(): string;
+    depth(): any;
+    getProperty(prop: any): any;
+    first(prop: any): any;
+    property(prop: any): any;
+    parentObject(): any;
+    root(): boolean;
+    renderProperties(): any[];
+    sortProperties(): string[];
+    standardCompare(a: any, b: any, doc: any): 0 | 1 | -1;
+    cardControlAllows(action: any): boolean;
+    isUpdated(): boolean;
+    isNew(): boolean;
+    getSummary(): {
+        status: string;
+    };
+    saveQuery(): any;
+    pathToDoc(q: any): void;
+    deleteQuery(): any;
+    getLabel: any;
+    getComment: any;
+}
+declare function PropertyFrame(property: any, cframe: any, parent: any): void;
+declare class PropertyFrame {
+    constructor(property: any, cframe: any, parent: any);
+    predicate: any;
+    cframe: any;
+    parent: any;
+    values: any[];
+    addJSONLDDocument(jsonld: any): void;
+    addFrame(frame: any): void;
+    addValueFrame(oframe: any): void;
+    addValue(val: any): any;
+    fillFromSchema(newid: any): void;
+    isData(): any;
+    isObject(): any;
+    isProperty(): boolean;
+    property(): any;
+    extract(): any[];
+    subject(): any;
+    subjectClass(): any;
+    depth(): any;
+    updated(): any;
+    range(): any;
+    getLabel(): any;
+    getComment(): any;
+    hasCardinalityRestriction(): any;
+    getRestriction(): any;
+    isClassChoice(): any;
+    deletePropertyValue(value: any, index: any): void;
+    removeValue(value: any, index: any): void;
+    get(): any[];
+    set(val: any): void;
+    clear(): void;
+    clone(): PropertyFrame;
+    getAsFrames(): any[];
+    createEmpty(): any;
+    mfilter(rules: any, onmatch: any): this;
+    first(): any;
+    renderValues(): any[];
+    sortValues(): any[];
+    cardControlAllows(action: any): boolean;
+    isUpdated(): boolean;
+    saveQuery(): import("../query/woqlBuilder");
+    deleteQuery(): import("../query/woqlBuilder");
+}

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

@@ -0,0 +1,23 @@
+export = WOQLStreamConfig;
+declare function WOQLStreamConfig(): void;
+declare class WOQLStreamConfig {
+    type: string;
+    create(client: any): WOQLStream;
+    row(): any;
+    template(template: any): any;
+    mtemplate: any;
+    prettyPrint(): string;
+    loadJSON(config: any, rules: any): void;
+    rules: WOQLStreamRule[];
+    json(): {
+        stream: {
+            template: any;
+        };
+        rules: any[];
+    };
+}
+import WOQLStream = require("./woqlStream");
+declare function WOQLStreamRule(): void;
+declare class WOQLStreamRule {
+    template(template: any): any;
+}

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

@@ -0,0 +1,66 @@
+export = WOQLTableConfig;
+declare function WOQLTableConfig(): void;
+declare class WOQLTableConfig {
+    type: string;
+    create(client: any): WOQLTable;
+    json(): {
+        table: {
+            column_order: any;
+            pagesize: any;
+            renderer: any;
+            filter: any;
+            filterable: boolean | WOQLTableConfig;
+            pager: any;
+            bindings: any;
+            page: any;
+            changesize: any;
+        };
+        rules: any[];
+    };
+    loadJSON(config: any, rules: any): this;
+    rules: WOQLTableRule[];
+    prettyPrint(): string;
+    /**
+     * Gets or sets whether the table is filterable
+     * @param {boolean} [canfilter] - If provided, sets the filterable state
+     * @returns {boolean|WOQLTableConfig} - Returns the filterable state (boolean) when called
+     * without arguments, or returns this instance (WOQLTableConfig) for chaining when setting
+     */
+    filterable(canfilter?: boolean): boolean | WOQLTableConfig;
+    tfilterable: boolean;
+    filter(filter: any): any;
+    tfilter: any;
+    renderer(rend: any): any;
+    trenderer: any;
+    header(theader: any): any;
+    theader: any;
+    /**
+     * @param  {...any} val
+     * @returns {object}
+     */
+    column_order(...val: any[]): object;
+    order: any[];
+    pager(val: any): any;
+    show_pager: any;
+    changesize(val: any): any;
+    change_pagesize: any;
+    pagesize(val: any): any;
+    show_pagesize: any;
+    page(val: any): any;
+    show_pagenumber: any;
+    column(...cols: any[]): any;
+    row(): any;
+}
+import WOQLTable = require("./woqlTable");
+declare function WOQLTableRule(): void;
+declare class WOQLTableRule {
+    header(hdr: any): any;
+    filter(hdr: any): any;
+    filterable(hdr: any): any;
+    width(wid: any): any;
+    maxWidth(wid: any): any;
+    minWidth(wid: any): any;
+    unsortable(unsortable: any): any;
+    uncompressed(uncompressed: any): any;
+    prettyPrint(): any;
+}

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

@@ -0,0 +1,75 @@
+/**
+ * @file Terminus Rules
+ * @license Apache Version 2
+ * Abstract object to support applying matching rules to result sets and documents
+ * sub-classes are FrameRule and WOQLRule - this just has common functions
+ */
+export function TerminusRule(): void;
+export class TerminusRule {
+    /**
+     * @param {Boolean} tf - the rule will match all literals or all non-literals
+     */
+    literal(tf: boolean): any;
+    /**
+     * @param {...string} list - parameters are types identified by prefixed URLS (xsd:string...)
+     */
+    type(...list: string[]): any;
+    /**
+     * Specifies the scope of a rule - row / cell / object / property / * .. what part
+     * of the result does the rule apply to
+     */
+    scope(scope: any): any;
+    /**
+     * Specifies that the rule matches a specific value
+     */
+    value(...val: any[]): any;
+    /**
+     * Produces a canonical json format to represent the rule
+     */
+    json(mjson: any): this | {
+        pattern: any;
+        rule: any;
+    };
+    rule: any;
+}
+/**
+ * Contained Pattern Object to encapsulate pattern matching
+ * @param {Object} pattern
+ */
+export function TerminusPattern(pattern: any): void;
+export class TerminusPattern {
+    /**
+     * Contained Pattern Object to encapsulate pattern matching
+     * @param {Object} pattern
+     */
+    constructor(pattern: any);
+    setPattern(pattern: any): void;
+    literal: any;
+    type: any;
+    scope: any;
+    value: any;
+    json(): {
+        literal: any;
+        type: any;
+        scope: any;
+        value: any;
+    };
+    /**
+     * Tests whether the passed values matches the basic pattern
+     */
+    testBasics(scope: any, value: any): boolean;
+    testValue(value: any, constraint: any): any;
+    /**
+     * Unpacks an array into a list of arguments
+     * @param {Boolean} nonstring - if set, the values will be double-quoted only when
+     * they are strings, otherwise, all will be quoted as strings
+     */
+    unpack(arr: any, nonstring: boolean): string;
+    IDsMatch(ida: any, idb: any): boolean;
+    classIDsMatch(ida: any, idb: any): boolean;
+    propertyIDsMatch(ida: any, idb: any): boolean;
+    rangeIDsMatch(ida: any, idb: any): boolean;
+    valuesMatch(vala: any, valb: any): boolean;
+    numberMatch(vala: any, valb: any): any;
+    stringMatch(vala: any, valb: any): boolean;
+}

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

@@ -0,0 +1,47 @@
+/**
+ * @module WOQLViewRule
+ * @constructor
+ */
+export function WOQLViewRule(): void;
+export class WOQLViewRule {
+    rule: {};
+    prettyPrint(type: any): string;
+    json(mjson: any): this | {
+        pattern: any;
+        rule: {};
+    };
+    size(size: any): any;
+    color(color: any): any;
+    icon(json: any): any;
+    text(json: any): any;
+    border(json: any): any;
+    renderer(rend: any): any;
+    render(func: any): any;
+    click(onClick: any): any;
+    hover(onHover: any): any;
+    hidden(hidden: any): any;
+    args(args: any): any;
+}
+/**
+ * Generic functions / configs that are available to all config types
+ * @module ViewConfig
+ * @constructor
+ */
+export function ViewConfig(): void;
+export class ViewConfig {
+    rules: any[];
+    render(func: any): any;
+    view_render: any;
+    renderer(val: any): any;
+    view_renderer: any;
+    getRulesJSON(): any[];
+    getBasicJSON(): {
+        render: any;
+        renderer: any;
+        bindings: any;
+    };
+    loadBasicJSON(json: any): void;
+    vbindings: any;
+    getBasicprettyPrint(): string;
+    bindings(bindings: any): any;
+}

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

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

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

@@ -0,0 +1,56 @@
+export = WOQLChooser;
+/**
+ * @typedef {Object} WOQLClient
+ */
+/**
+ * Very simple implementation of a WOQL backed chooser
+ * Makes a drop down from a WOQL query - configuration tells it which columns to use...
+ * @param {WOQLClient} client
+ * @param {WOQLChooserConfig} config
+ * @returns {WOQLChooser}
+ */
+declare function WOQLChooser(client: WOQLClient, config: WOQLChooserConfig): WOQLChooser;
+declare class WOQLChooser {
+    /**
+     * @typedef {Object} WOQLClient
+     */
+    /**
+     * Very simple implementation of a WOQL backed chooser
+     * Makes a drop down from a WOQL query - configuration tells it which columns to use...
+     * @param {WOQLClient} client
+     * @param {WOQLChooserConfig} config
+     * @returns {WOQLChooser}
+     */
+    constructor(client: WOQLClient, config: WOQLChooserConfig);
+    client: any;
+    config: WOQLChooserConfig;
+    selected: boolean;
+    cursor: number;
+    options(config: any): this;
+    set(id: any): void;
+    setResult(result: any): this;
+    result: any;
+    choices: any[];
+    includeRow(row: any, index: any): boolean;
+    rowToChoice(row: any, rownum: any): {
+        id: any;
+    };
+    getRowID(row: any): any;
+    getLabelFromBinding(row: any, rownum: any): any;
+    getTitleFromBinding(row: any, rownum: any): any;
+    getSelectedFromBinding(row: any, rownum: any): any;
+    render(): any;
+    setRenderer(rend: any): this;
+    renderer: any;
+    getSpecialRenderer(row: any, index: any, type: any): any;
+    renderSpecial(rule: any, row: any): any;
+    count(): any;
+    first(): any;
+    next(): any;
+    prev(): any;
+}
+declare namespace WOQLChooser {
+    export { WOQLClient };
+}
+import WOQLChooserConfig = require("./chooserConfig");
+type WOQLClient = any;