terminusdb 12.0.2

package/dist/typescript/lib/utils.d.ts

@@ -0,0 +1,199 @@
+export function checkValidName(str: any): boolean;
+export namespace ACTIONS {
+    let CREATE_DATABASE: string;
+    let DELETE_DATABASE: string;
+    let SCHEMA_READ_ACCESS: string;
+    let SCHEMA_WRITE_ACCESS: string;
+    let INSTANCE_READ_ACCESS: string;
+    let INSTANCE_WRITE_ACCESS: string;
+    let COMMIT_READ_ACCESS: string;
+    let COMMIT_WRITE_ACCESS: string;
+    let META_READ_ACCESS: string;
+    let META_WRITE_ACCESS: string;
+    let CLASS_FRAME: string;
+    let BRANCH: string;
+    let CLONE: string;
+    let FETCH: string;
+    let PUSH: string;
+    let REBASE: string;
+}
+export function encodeURISegment(str: any): any;
+export function decodeURISegment(str: any): any;
+export function removeDocType(str: any): any;
+export let standard_urls: object;
+/**
+ * Encode document payload for GET
+ * @param {string | object} payload
+ * @returns {string}
+ */
+export function URIEncodePayload(payload: string | object): string;
+/**
+ * Adds an entry to the list of known standard URL prefixes
+ * @param {string} prefix
+ * @param {string} url
+ */
+export function addURLPrefix(prefix: string, url: string): void;
+/**
+ * is the object empty?
+ * returns true if the json object is empty
+ * @param {object|array} [obj]
+ * @returns {boolean}
+ */
+export function empty(obj?: object | any[]): boolean;
+/**
+ * Generates a unique node id
+ * @param {string} [base]
+ * @returns {string}
+ */
+export function genBNID(base?: string): string;
+/**
+ * Returns the shorthand version (compressed to prefix:id ) of a url or
+ * false if there is none known for that URL
+ * @param {object | string} link
+ * @returns {string | boolean}
+ */
+export function getShorthand(link: object | string): string | boolean;
+/**
+ * Compares 2 IRIs for equality by checking compressed and expanded versions of both sides
+ * @param {string} ida
+ * @param {string} idb
+ * @returns {boolean}
+ */
+export function compareIDs(ida: string, idb: string): boolean;
+/**
+ * Shortens a URL to its compressed format - returns the full URL if not possible
+ * @param {string} [url]
+ * @param {string} [prefixes]
+ * @returns {string | undefined}
+ */
+export function shorten(url?: string, prefixes?: string): string | undefined;
+/**
+ * Expands a URL to its full URL format - returns the passed string if not possible to expand
+ * @param {string} [url]
+ * @returns {string | undefined}
+ */
+export function unshorten(url?: string): string | undefined;
+/**
+ * shortens a jsonld document to its prefixed form
+ * @param {array|object|string} jsonld
+ * @param {string} [prefixes]
+ * @returns {string|array|object}
+ */
+export function json_shorten(jsonld: any[] | object | string, prefixes?: string): string | any[] | object;
+/**
+ * Unshortens a jsonld document to its full form
+ * @param {array|object|string} jsonld
+ * @param {string} [prefixes]
+ * @returns {string|array|object}
+ */
+export function json_unshorten(jsonld: any[] | object | string, prefixes?: string): string | any[] | object;
+/**
+ * Tests a string to see if it is a valid URL -
+ * Valid URLs are those that start with http:// or https://
+ */
+export function validURL(str: any): boolean;
+/**
+ * Tests a string to see if it is a valid URL -
+ * Valid URLs are those that start with http:// or https://
+ * @param {string} str
+ * @param {string | object} [context]
+ * @param {boolean} [allow_shorthand]
+ * @returns {boolean}
+ */
+export function isIRI(str: string, context?: string | object, allow_shorthand?: boolean): boolean;
+/**
+ * Generates a text label from a URL
+ * @param {string} url
+ * @returns {string}
+ */
+export function labelFromURL(url: string): string;
+/**
+ * Generates a text label from a URL
+ */
+export function labelFromVariable(v: any): any;
+/**
+ * returns the fragment part of a URL (whether compressed or not)
+ */
+export function urlFragment(url: any): any;
+/**
+ * returns the last part of a URL after the last /
+ */
+export function lastURLBit(url: any): any;
+/**
+ * returns the a standard URL associated with a given prefix and extension
+ */
+export function getStdURL(pref: any, ext: any, url: any): any;
+export function addNamespacesToVariables(vars: any): any[];
+export function addNamespaceToVariable(v: any): any;
+export function removeNamespaceFromVariable(mvar: any): any;
+export function removeNamespacesFromVariables(vars: any): any[];
+export function getConfigValue(val: any, row: any): any;
+export namespace TypeHelper {
+    /**
+     * Returns true if the passed type is an xsd:string (compressed or not)
+     */
+    function isStringType(stype: any): boolean;
+    function isDatatype(stype: any): boolean;
+    /**
+     * Adds 3 order magnitude separators ( default ,) into big numbers for legibility
+     */
+    function numberWithCommas(value: any, separator: any): any;
+    function formatBytes(bytes: any, decimals?: number): string;
+    let datatypes: string[];
+    function parseRangeValue(val: any, dividor: any): any;
+}
+export namespace DateHelper {
+    /**
+     * Takes an xsd time string and returns a structure {hour: HH, minute: MM,
+     * second ss.ssssss, timezone: tz}
+     */
+    function parseXsdTime(val: any): {};
+    /**
+     * Takes an xsd time string and returns a structure {year: [-]YYYY, month: MM, day: dd}
+     */
+    function parseXsdDate(val: any): false | {
+        year: any;
+        month: any;
+        day: any;
+        timezone: string | boolean;
+    };
+    /**
+     * Parses a date string of type ty
+     */
+    function parseDate(ty: any, value: any): {};
+    /**
+     * adds appropriate padding to date type for xsd rules
+     */
+    function addXsdPadding(parsed: any): {
+        year: any;
+        month: any;
+        day: any;
+        hour: any;
+        minute: any;
+        second: any;
+    };
+    /**
+     * generates an xsd string of type ty for the passed parsed structure (year, month, day, hour,
+     * minute, second, timezone)
+     */
+    function xsdFromParsed(parsed: any, ty: any): any;
+    /**
+     * Converts between a unix timestamp and a parsed structure
+     */
+    function convertTimestampToXsd(val: any): {
+        year: number;
+        month: number;
+        day: number;
+        hour: number;
+        minute: number;
+        second: number;
+    };
+    /**
+     * Parses an xsd date time into a structure
+     */
+    function parseXsdDateTime(val: any): {};
+    /**
+     * Extracts the timezone data from an xsd date string
+     */
+    function extractXsdTimezone(val: any): false | "Z";
+}

package/dist/typescript/lib/valueHash.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Compute the ValueHash for a document
+ *
+ * @param {object} doc - The document to hash
+ * @param {object} [options] - Options for hash computation
+ * @param {object} [options.context] - The context with prefix mappings
+ * @param {object} [options.schema] - Optional schema information
+ * @returns {string} The computed ValueHash (SHA256 hex string)
+ */
+export function computeValueHash(doc: object, options?: {
+    context?: object;
+    schema?: object;
+}): string;
+/**
+ * Generate the full @id for a document using ValueHash
+ *
+ * @param {object} doc - The document to generate ID for
+ * @param {object} [options] - Options for ID generation
+ * @param {object} [options.context] - The context with prefix mappings
+ * @param {object} [options.schema] - Optional schema information
+ * @returns {string} The full document @id with ValueHash
+ */
+export function generateValueHashId(doc: object, options?: {
+    context?: object;
+    schema?: object;
+}): string;
+/**
+ * Set the @id of a document using ValueHash, recursively processing subdocuments
+ *
+ * @param {object} doc - The document to set ID for
+ * @param {object} [options] - Options for ID generation
+ * @param {object} [options.context] - The context with prefix mappings
+ * @param {object} [options.schema] - Optional schema information
+ * @returns {object} The document with @id set (and subdocuments processed)
+ */
+export function setValueHashId(doc: object, options?: {
+    context?: object;
+    schema?: object;
+}): object;
+/**
+ * Elaborate a document by expanding IRIs and adding type information
+ * This is a simplified version that works for ValueHash computation
+ *
+ * @param {object} doc - The document to elaborate
+ * @param {object} context - The context with prefix mappings
+ * @param {object} schema - Optional schema information for type inference
+ * @returns {object} The elaborated document
+ */
+export function elaborateDocument(doc: object, context: object, schema?: object): object;
+/**
+ * Extract all path-value pairs from an elaborated document
+ * This matches TerminusDB's get_all_path_values/2 predicate
+ *
+ * @param {object} doc - The elaborated document
+ * @param {Array} currentPath - The current path (for recursion)
+ * @returns {Array} Array of [path, formattedValue] pairs
+ */
+export function extractPathValues(doc: object, currentPath?: any[]): any[];
+/**
+ * Expand a prefixed IRI using the context
+ * @param {string} iri - The IRI to expand (may be prefixed like "xsd:string")
+ * @param {object} context - The context object with prefix mappings
+ * @returns {string} The expanded IRI
+ */
+export function expandIRI(iri: string, context: object): string;
+/**
+ * Get the base IRI for a type
+ * @param {string} type - The type name
+ * @param {object} context - The context object
+ * @returns {string} The base IRI for document IDs of this type
+ */
+export function getTypeBase(type: string, context: object): string;
+/**
+ * Format an atom for Prolog quoted output
+ * Atoms containing special characters or starting with uppercase need quoting
+ * @param {string} atom - The atom to format
+ * @returns {string} The formatted atom
+ */
+export function formatPrologAtom(atom: string): string;
+/**
+ * Format a string for Prolog quoted output (escape special characters)
+ * @param {string} str - The string to format
+ * @returns {string} The formatted string
+ */
+export function formatPrologString(str: string): string;
+/**
+ * Format a typed value in Prolog format: (value^^type)
+ * For strings: ("value"^^'type')
+ * For numbers: (42^^'type')
+ * For booleans: (true^^'type')
+ * @param {any} value - The value
+ * @param {string} type - The XSD type IRI
+ * @returns {string} The formatted typed value
+ */
+export function formatTypedValue(value: any, type: string): string;
+/**
+ * Format a path (list of keys) in Prolog format: [key1,key2,...]
+ * @param {Array} path - The path as array of keys
+ * @returns {string} The formatted path
+ */
+export function formatPrologPath(path: any[]): string;
+/**
+ * Format a path-value pair in Prolog format: [path]-value
+ * @param {Array} path - The path
+ * @param {any} value - The value (already formatted)
+ * @returns {string} The formatted pair
+ */
+export function formatPathValuePair(path: any[], value: any): string;
+export namespace XSD_TYPES {
+    let string: string;
+    let integer: string;
+    let decimal: string;
+    let double: string;
+    let float: string;
+    let boolean: string;
+    let date: string;
+    let dateTime: string;
+    let time: string;
+    let gYear: string;
+    let gMonth: string;
+    let gDay: string;
+    let gYearMonth: string;
+    let gMonthDay: string;
+    let duration: string;
+    let anyURI: string;
+    let base64Binary: string;
+    let hexBinary: string;
+    let long: string;
+    let short: string;
+    let byte: string;
+    let unsignedLong: string;
+    let unsignedInt: string;
+    let unsignedShort: string;
+    let unsignedByte: string;
+    let positiveInteger: string;
+    let negativeInteger: string;
+    let nonPositiveInteger: string;
+    let nonNegativeInteger: string;
+}
+/**
+ * Default context prefixes
+ */
+export const DEFAULT_CONTEXT: {
+    '@base': string;
+    '@schema': string;
+};

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

@@ -0,0 +1,62 @@
+export = WOQLChartConfig;
+declare function WOQLChartConfig(): void;
+declare class WOQLChartConfig {
+    type: string;
+    prettyPrint(): string;
+    json(): {
+        chart: {
+            margin: any;
+            title: any;
+            description: any;
+            layout: any;
+            align: any;
+        };
+        rules: any;
+    };
+    loadJSON(config: any, rules: any): void;
+    rules: WOQLChartRule[];
+    title(title: any): any;
+    _title: any;
+    description(description: any): any;
+    _description: any;
+    layout(layout: any): any;
+    _layout: any;
+    align(align: any): any;
+    _align: any;
+    margin(marginObj: any): any;
+    _margin: any;
+    create(client: any): WOQLChartConfig;
+    xAxis(...vars: any[]): any;
+    legend(...vars: any[]): any;
+    yAxis(...vars: any[]): any;
+    bar(...vars: any[]): any;
+    line(...vars: any[]): any;
+    point(...vars: any[]): any;
+    area(...vars: any[]): any;
+}
+/**
+ *
+ * @param {Chart} scope
+ */
+declare function WOQLChartRule(): void;
+declare class WOQLChartRule {
+    style(key: any, value: any): any;
+    label(label: any): any;
+    legendType(legendType: any): any;
+    fillOpacity(fillOpacity: any): any;
+    fill(color: any): any;
+    stroke(color: any): any;
+    strokeWidth(size: any): any;
+    dot(isVisible: any): any;
+    labelRotate(angle: any): any;
+    padding(paddingObj: any): any;
+    labelDateInput(labelDateInput: any): any;
+    labelDateOutput(labelDateOutput: any): any;
+    stackId(stackId: any): any;
+    type(type: any): any;
+    axisDomain(domainArr: any): any;
+    colorEntry(propValue: any): any;
+    customColors(colorsObj: any): any;
+    payload(payloadArr: any): any;
+    barSize(barSize: any): any;
+}

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

@@ -0,0 +1,38 @@
+export = WOQLChooserConfig;
+declare function WOQLChooserConfig(): void;
+declare class WOQLChooserConfig {
+    type: string;
+    create(client: any): WOQLChooser;
+    prettyPrint(): string;
+    json(): {
+        chooser: any;
+        rules: any;
+    };
+    loadJSON(config: any, rules: any): void;
+    rules: WOQLChooserRule[];
+    change(v: any): any;
+    onChange: any;
+    show_empty(p: any): any;
+    placeholder: any;
+    rule(v: any): any;
+    values(v: any): any;
+    value_variable: any;
+    labels(v: any): any;
+    label_variable: any;
+    titles(v: any): any;
+    title_variable: any;
+    sort(v: any): any;
+    sort_variable: any;
+    direction(v: any): any;
+    sort_direction: any;
+}
+import WOQLChooser = require("./woqlChooser");
+declare function WOQLChooserRule(scope: any): void;
+declare class WOQLChooserRule {
+    constructor(scope: any);
+    label(l: any): any;
+    title(l: any): any;
+    values(l: any): any;
+    selected(s: any): any;
+    prettyPrint(): any;
+}

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

@@ -0,0 +1,44 @@
+export = DocumentFrame;
+/**
+ * @file Document Frame
+ * @license Apache Version 2
+ */
+declare function DocumentFrame(client: any, config: any): void;
+declare class DocumentFrame {
+    /**
+     * @file Document Frame
+     * @license Apache Version 2
+     */
+    constructor(client: any, config: any);
+    client: any;
+    config: any;
+    load_schema: boolean;
+    options(opts: any): this;
+    db(dburl: any): this;
+    /**
+     *  @param {String} url - loads the document frame from the document API in frame form
+     *  - loads the frame encapsulates more meta-data in the json and reduces the
+     * number of api calls we need to make
+     *  @returns {Promise}
+     */
+    loadDocument(url: string, encoding: any): Promise<any>;
+    loadSchema(cls: any, dbURL: any): any;
+    /**
+     *  @param {String} url - loads the document frame along with its class frame
+     *  @param {String} [cls] - optional class id of the document - if absent class frames
+     * will be loaded from the document class once it is loaded
+     *  @returns {Promise}
+     *  - loads a document frame and it's class frame in unison
+     */
+    loadComplete(url: string, cls?: string): Promise<any>;
+    loadJSON(json: any, type: any): any;
+    loadData(jsonld: any, cls: any, classframes: any): void;
+    document: ObjectFrame;
+    load(classframes: any, doc: any): void;
+    loadSchemaFrames(classframes: any, cls: any): void;
+    filterFrame(loadRenderer: any): void;
+    setErrors(errors: any, frameconf: any): void;
+    clearErrors(frameconf: any): void;
+    applyRules(doc: any, config: any, mymatch: any): void;
+}
+import ObjectFrame = require("./objectFrame");

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

@@ -0,0 +1,74 @@
+export = FrameConfig;
+/**
+ * @file Frame Config
+ * @license Apache Version 2
+ */
+declare function FrameConfig(): void;
+declare class FrameConfig {
+    type: string;
+    create(client: any): DocumentFrame;
+    prettyPrint(): string;
+    json(): {
+        frame: any;
+        rules: any;
+    };
+    loadJSON(config: any, rules: any): this;
+    rules: DocumentRule[];
+    json_rules(): any[];
+    load_schema(tf: any): any;
+    get_schema: any;
+    show_all(r: any): this;
+    show_parts(o: any, p: any, d: any): this;
+    object(): any;
+    property(): any;
+    scope(scope: any): any;
+    data(): any;
+    all(): any;
+    /**
+     * Attaches display options to frames from matching rules
+     */
+    setFrameDisplayOptions(frame: any, rule: any): void;
+    setFrameFeatures(existing: any, fresh: any): any;
+    setFrameArgs(existing: any, fresh: any): any;
+}
+import DocumentFrame = require("./documentFrame.js");
+/**
+ * @file Document Rule
+ * @license Apache Version 2
+ */
+declare function DocumentRule(): void;
+declare class DocumentRule {
+    rule: {};
+    renderer(rend: any): any;
+    compare(func: any): any;
+    mode(mode: any): any;
+    collapse(func: any): any;
+    view(m: any): any;
+    /**
+     * Should actions which are disabled in the given context be displayed?
+     */
+    showDisabledButtons(m: any): any;
+    header(m: any): any;
+    errors(errs: any): any;
+    headerStyle(m: any): any;
+    showEmpty(m: any): any;
+    dataviewer(m: any): any;
+    features(...m: any[]): any;
+    headerFeatures(...m: any[]): any;
+    render(func: any): any;
+    style(style: any): any;
+    /**
+     * The frame or feature will be hidden or unhidden (boolean)
+     */
+    hidden(m: any): any;
+    /**
+     * Specifies arguments to a renderer
+     */
+    args(json: any): any;
+    /**
+     * Adds a property to a feature array
+     */
+    applyFeatureProperty(feats: any, prop: any, val: any): {}[];
+    unpackFeatures(feats: any): string;
+    prettyPrint(): any;
+}