@spectric/ui 0.0.4 → 0.0.6

package/dist/components/input.d.ts

@@ -0,0 +1,156 @@
+import { LitElement, TemplateResult } from 'lit';
+import { ReactElementWithPropsAndEvents } from './types';
+export declare enum InputVariants {
+    Text = "text",
+    TextArea = "text-area",
+    number = "number",
+    color = "color",
+    date = "date",//replace default eventually with custom
+    datetime = "datetime-local",//replace default eventually with custom
+    email = "email",
+    file = "file",//display drop area
+    hidden = "hidden",//display drop area
+    password = "password"
+}
+type InputVariantsTypes = `${InputVariants}`;
+export interface InputProps {
+    /** Input type */
+    variant: InputVariantsTypes;
+    /**Label to display above the input */
+    label: string;
+    /**placeholder text to display*/
+    placeholder: string;
+    disabled: boolean;
+    readonly: boolean;
+    /**
+   * The helper text.
+   */
+    helperText: string;
+    /**
+     * Specify if the currently value is invalid.
+     */
+    invalid: boolean;
+    /**
+     * Message which is displayed if the value is invalid.
+     */
+    invalidText: string | TemplateResult<1>;
+    /**
+     * Max character count allowed for input. This is needed in order for enableCounter to display
+     */
+    maxCount: number;
+    /**
+  * Boolean property to set the required status
+  */
+    required?: boolean;
+    /**
+  * Shows a button to display the password
+  */
+    showPasswordVisibilityToggle?: boolean;
+    /**
+   * Name for the input used for form data events //TODO make sure this works
+   */
+    name?: string;
+    /**
+     * Pattern to validate the input against for HTML validity checking
+     */
+    pattern?: string;
+    /**
+     * The sets the autocomplete for the input.
+     */
+    autocomplete: HTMLInputElement['autocomplete'];
+}
+export declare class SpectricInput extends LitElement implements InputProps {
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    placeholder: string;
+    readonly: boolean;
+    variant: InputVariantsTypes;
+    disabled: boolean;
+    label: string;
+    /**
+    * "Hide password" tooltip text on password visibility toggle
+    */
+    hidePasswordLabel: string;
+    /**
+     * "Show password" tooltip text on password visibility toggle
+     */
+    showPasswordLabel: string;
+    /**
+     * Boolean property to render password visibility toggle
+     */
+    showPasswordVisibilityToggle: boolean;
+    /**
+     * The helper text.
+     */
+    helperText: string;
+    /**
+     * Specify if the currently value is invalid.
+     */
+    invalid: boolean;
+    /**
+     * Boolean property to set the required status
+     */
+    required: boolean;
+    /**
+     * Message which is displayed if the value is invalid.
+     */
+    invalidText: InputProps["invalidText"];
+    /**
+     * Name for the input used for form data events //TODO make sure this works
+     */
+    name: string;
+    /**
+     * Pattern to validate the input against for HTML validity checking
+     */
+    pattern: string;
+    maxCount: InputProps['maxCount'];
+    /**
+  * The internal value.
+  */
+    protected _value: string | boolean | number;
+    private _showPassword;
+    /**
+     * The sets the autocomplete for the input.
+     */
+    autocomplete: HTMLInputElement['autocomplete'];
+    get selectionStart(): number | null;
+    /**
+     * The value of the input.
+     */
+    get value(): string | number | boolean;
+    set value(value: string | number | boolean);
+    setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
+    /**
+   * Handles `oninput` event on the `<input>`.
+   */
+    protected _handleInput: ({ target }: Event) => void;
+    /**
+    * The underlying input element
+    */
+    protected _input: HTMLInputElement;
+    private handleTogglePasswordVisibility;
+    protected render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "spectric-input": SpectricInput;
+    }
+    namespace JSX {
+        interface IntrinsicElements {
+            /**
+             * {@link SpectricInput}
+             */
+            "spectric-input": ReactElementWithPropsAndEvents<SpectricInput, InputProps>;
+        }
+    }
+    namespace React {
+        namespace JSX {
+            interface IntrinsicElements {
+                /**
+                 * {@link SpectricInput}
+                 */
+                "spectric-input": ReactElementWithPropsAndEvents<SpectricInput, InputProps>;
+            }
+        }
+    }
+}
+export {};

package/dist/components/page.css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/dist/components/panel.css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/dist/components/query_bar/QueryBar.d.ts

@@ -0,0 +1,113 @@
+import { LitElement, PropertyValues } from 'lit';
+import { SpectricInput } from '../input';
+import { JsonObject } from './types';
+import { HTMLElementTagWithEvents, ReactElementWithPropsAndEvents } from '../types';
+import * as kuery from "./querylanguage/kuery";
+export type FieldTypes = {
+    name: string;
+    type: "string" | "number" | "boolean";
+    format?: "date-time";
+};
+type SuggestionType = 'conjunction' | "field" | 'operator' | 'value';
+type Suggestion = {
+    fieldName: string;
+    end: number;
+    prefix: string;
+    start: number;
+    suffix: string;
+    suggestionTypes: (SuggestionType)[];
+    text: string;
+    type: "cursor";
+};
+export declare enum SupportedLanguages {
+    MONGO = "toMongo",
+    CQL = "toCql",
+    DSL = "toDSL",
+    AST = "AST"
+}
+type SupportedLanguagesTypes = `${SupportedLanguages}`;
+interface QueryEventMap {
+    "change": (event: CustomEvent<string | kuery.KueryNode | JsonObject>) => void;
+}
+export interface IQueryProps {
+    /**
+     * The output of the query in a specific format
+     */
+    outputLanguage: SupportedLanguagesTypes;
+    /**
+     * The output of the query
+     */
+    value: string;
+    /**
+     * Fields that are used for the auto complete
+     */
+    fields: FieldTypes[];
+    /**
+     * Callback that will provide values for specific fields
+     */
+    getValuesForField: (field: string, text: string) => Promise<string[]>;
+    /**
+     * Input placeholder
+     */
+    placeholder: string;
+}
+/**
+ * The Query component will take Opensearch Dashboard Query language and transform it into various outputs
+ */
+export declare class SpectricQuery extends LitElement implements IQueryProps {
+    private uuid;
+    placeholder: string;
+    constructor();
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    /**
+    * The internal value.
+    */
+    protected _value: string;
+    private suggestion?;
+    /**
+     * The value of the input.
+     */
+    get value(): string;
+    set value(value: string);
+    outputLanguage: SupportedLanguagesTypes;
+    private completions;
+    private completionIndex;
+    fields: FieldTypes[];
+    _autocomplete?: HTMLDivElement;
+    _asyncAutocomplete: Promise<HTMLDivElement>;
+    /**
+    * The underlying input element
+    */
+    protected _input: SpectricInput;
+    _parseQuery: (e?: InputEvent | undefined) => void;
+    getValuesForField: (field: string, text: string) => Promise<string[]>;
+    autoComplete(suggestion: Suggestion): Promise<void>;
+    protected updated(changed: PropertyValues): void;
+    _selectCompletion: () => Promise<void>;
+    _handleArrows: (e: KeyboardEvent) => void;
+    protected render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "spectric-query": HTMLElementTagWithEvents<SpectricQuery, QueryEventMap>;
+    }
+    namespace JSX {
+        interface IntrinsicElements {
+            /**
+             * {@link SpectricQuery}
+             */
+            "spectric-query": ReactElementWithPropsAndEvents<SpectricQuery, IQueryProps, QueryEventMap>;
+        }
+    }
+    namespace React {
+        namespace JSX {
+            interface IntrinsicElements {
+                /**
+                 * {@link SpectricQuery}
+                 */
+                "spectric-query": ReactElementWithPropsAndEvents<SpectricQuery, IQueryProps, QueryEventMap>;
+            }
+        }
+    }
+}
+export {};

package/dist/components/query_bar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './QueryBar';
+export * from './types';

package/dist/components/query_bar/querylanguage/kuery/ast/ast.d.ts

@@ -0,0 +1,13 @@
+import { KueryNode, DslQuery, KueryParseOptions } from '../types';
+import { JsonObject, IIndexPattern, FieldTypes } from '../../..';
+export declare const fromLiteralExpression: (expression: string | DslQuery, parseOptions?: Partial<KueryParseOptions>) => KueryNode;
+export declare const fromKueryExpression: (expression: string | DslQuery, parseOptions?: Partial<KueryParseOptions>) => KueryNode;
+export declare const doesKueryExpressionHaveLuceneSyntaxError: (expression: string | DslQuery) => boolean;
+/**
+ * @params {String} indexPattern
+ * @params {Object} config - contains the dateFormatTZ
+ *
+ * IndexPattern isn't required, but if you pass one in, we can be more intelligent
+ * about how we craft the queries (e.g. scripted fields)
+ */
+export declare const toOpenSearchQuery: (node: KueryNode, indexPattern?: IIndexPattern | FieldTypes[], config?: Record<string, any>, context?: Record<string, any>) => JsonObject;

package/dist/components/query_bar/querylanguage/kuery/ast/index.d.ts

@@ -0,0 +1 @@
+export * from './ast';

package/dist/components/query_bar/querylanguage/kuery/functions/and.d.ts

@@ -0,0 +1,9 @@
+import { IIndexPattern, KueryNode } from '../../..';
+export declare function buildNodeParams(children: KueryNode[]): {
+    arguments: KueryNode[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): {
+    bool: {
+        filter: any;
+    };
+};

package/dist/components/query_bar/querylanguage/kuery/functions/exists.d.ts

@@ -0,0 +1,10 @@
+import { IIndexPattern, KueryNode } from '../../../';
+export declare function buildNodeParams(fieldName: string): {
+    arguments: import('..').LiteralTypeBuildNode[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, //@ts-ignore
+config?: Record<string, any>, context?: Record<string, any>): {
+    exists: {
+        field: string | number | boolean | null;
+    };
+};

package/dist/components/query_bar/querylanguage/kuery/functions/index.d.ts

@@ -0,0 +1 @@
+export declare const functions: any;

package/dist/components/query_bar/querylanguage/kuery/functions/is.d.ts

@@ -0,0 +1,34 @@
+import { IIndexPattern, KueryNode } from '../../..';
+export declare function buildNodeParams(fieldName: string, value: any, isPhrase?: boolean): {
+    arguments: (import('..').LiteralTypeBuildNode | import('..').KueryNode)[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): {
+    query_string: {
+        query: string;
+    };
+    multi_match?: undefined;
+    match_all?: undefined;
+    bool?: undefined;
+} | {
+    multi_match: {
+        type: string;
+        query: any;
+        lenient: boolean;
+    };
+    query_string?: undefined;
+    match_all?: undefined;
+    bool?: undefined;
+} | {
+    match_all: {};
+    query_string?: undefined;
+    multi_match?: undefined;
+    bool?: undefined;
+} | {
+    bool: {
+        should: any[];
+        minimum_should_match: number;
+    };
+    query_string?: undefined;
+    multi_match?: undefined;
+    match_all?: undefined;
+};

package/dist/components/query_bar/querylanguage/kuery/functions/nested.d.ts

@@ -0,0 +1,11 @@
+import { IIndexPattern, KueryNode } from '../../..';
+export declare function buildNodeParams(path: any, child: any): {
+    arguments: any[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): {
+    nested: {
+        path: string | import('../../..').JsonObject;
+        query: import('../../..').JsonObject;
+        score_mode: string;
+    };
+};

package/dist/components/query_bar/querylanguage/kuery/functions/not.d.ts

@@ -0,0 +1,9 @@
+import { IIndexPattern, KueryNode } from '../../..';
+export declare function buildNodeParams(child: KueryNode): {
+    arguments: KueryNode[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): {
+    bool: {
+        must_not: import('../../..').JsonObject;
+    };
+};

package/dist/components/query_bar/querylanguage/kuery/functions/or.d.ts

@@ -0,0 +1,10 @@
+import { IIndexPattern, KueryNode } from '../../..';
+export declare function buildNodeParams(children: KueryNode[]): {
+    arguments: KueryNode[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): {
+    bool: {
+        should: any;
+        minimum_should_match: number;
+    };
+};

package/dist/components/query_bar/querylanguage/kuery/functions/range.d.ts

@@ -0,0 +1,10 @@
+import { IIndexPattern, KueryNode } from '../../..';
+export declare function buildNodeParams(fieldName: string, params: any): {
+    arguments: (import('..').LiteralTypeBuildNode | import('..').NamedArgTypeBuildNode | import('..').KueryNode)[];
+};
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): {
+    bool: {
+        should: any[];
+        minimum_should_match: number;
+    };
+};

package/dist/components/query_bar/querylanguage/kuery/functions/utils/get_fields.d.ts

@@ -0,0 +1,2 @@
+import { KueryNode, IIndexPattern } from '../../../..';
+export declare function getFields(node: KueryNode, indexPattern?: IIndexPattern): import('../../../..').IFieldType[] | undefined;

package/dist/components/query_bar/querylanguage/kuery/functions/utils/get_full_field_name_node.d.ts

@@ -0,0 +1,2 @@
+import { IIndexPattern, KueryNode } from '../../../../types';
+export declare function getFullFieldNameNode(rootNameNode: any, indexPattern?: IIndexPattern, nestedPath?: string): KueryNode;

package/dist/components/query_bar/querylanguage/kuery/index.d.ts

@@ -0,0 +1,7 @@
+export { DQLSyntaxError } from './kuery_syntax_error';
+export { nodeTypes } from './node_types';
+export * from './ast';
+export { fromKueryExpression as parse, toOpenSearchQuery as toDSL } from './ast';
+export { toCql } from '../outputTypes/toCQL';
+export { toMongo } from '../outputTypes/toMongo';
+export * from './types';

package/dist/components/query_bar/querylanguage/kuery/kuery_syntax_error.d.ts

@@ -0,0 +1,13 @@
+interface DQLSyntaxErrorData extends Error {
+    found: string;
+    expected: DQLSyntaxErrorExpected[] | null;
+    location: any;
+}
+interface DQLSyntaxErrorExpected {
+    description: string;
+}
+export declare class DQLSyntaxError extends Error {
+    shortMessage: string;
+    constructor(error: DQLSyntaxErrorData, expression: any);
+}
+export {};

package/dist/components/query_bar/querylanguage/kuery/node_types/function.d.ts

@@ -0,0 +1,5 @@
+import { IIndexPattern, KueryNode } from '../../..';
+import { FunctionName, FunctionTypeBuildNode } from './types';
+export declare function buildNode(functionName: FunctionName, ...args: any[]): any;
+export declare function buildNodeWithArgumentNodes(functionName: FunctionName, args: any[]): FunctionTypeBuildNode;
+export declare function toOpenSearchQuery(node: KueryNode, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>): any;

package/dist/components/query_bar/querylanguage/kuery/node_types/index.d.ts

@@ -0,0 +1,3 @@
+import { NodeTypes } from './types';
+export * from './types';
+export declare const nodeTypes: NodeTypes;

package/dist/components/query_bar/querylanguage/kuery/node_types/literal.d.ts

@@ -0,0 +1,3 @@
+import { LiteralTypeBuildNode } from './types';
+export declare function buildNode(value: LiteralTypeBuildNode['value']): LiteralTypeBuildNode;
+export declare function toOpenSearchQuery(node: LiteralTypeBuildNode): LiteralTypeBuildNode['value'];

package/dist/components/query_bar/querylanguage/kuery/node_types/named_arg.d.ts

@@ -0,0 +1,4 @@
+import { NamedArgTypeBuildNode } from './types';
+import { JsonObject } from '../../../types';
+export declare function buildNode(name: string, value: any): NamedArgTypeBuildNode;
+export declare function toOpenSearchQuery(node: any): JsonObject;

package/dist/components/query_bar/querylanguage/kuery/node_types/types.d.ts

@@ -0,0 +1,49 @@
+import { JsonValue, IIndexPattern } from '../../../types';
+import { KueryNode } from '..';
+export type FunctionName = 'is' | 'and' | 'or' | 'not' | 'range' | 'exists' | 'geoBoundingBox' | 'geoPolygon' | 'nested';
+interface FunctionType {
+    buildNode: (functionName: FunctionName, ...args: any[]) => FunctionTypeBuildNode;
+    buildNodeWithArgumentNodes: (functionName: FunctionName, args: any[]) => FunctionTypeBuildNode;
+    toOpenSearchQuery: (node: any, indexPattern?: IIndexPattern, config?: Record<string, any>, context?: Record<string, any>) => JsonValue;
+}
+export interface FunctionTypeBuildNode {
+    type: 'function';
+    function: FunctionName;
+    arguments: any[];
+}
+interface LiteralType {
+    buildNode: (value: null | boolean | number | string) => LiteralTypeBuildNode;
+    toOpenSearchQuery: (node: any) => null | boolean | number | string;
+}
+export interface LiteralTypeBuildNode {
+    type: 'literal';
+    value: null | boolean | number | string;
+}
+interface NamedArgType {
+    buildNode: (name: string, value: any) => NamedArgTypeBuildNode;
+    toOpenSearchQuery: (node: any) => JsonValue;
+}
+export interface NamedArgTypeBuildNode {
+    type: 'namedArg';
+    name: string;
+    value: any;
+}
+interface WildcardType {
+    wildcardSymbol: string;
+    buildNode: (value: string) => WildcardTypeBuildNode | KueryNode;
+    test: (node: any, string: string) => boolean;
+    toOpenSearchQuery: (node: any) => string;
+    toQueryStringQuery: (node: any) => string;
+    hasLeadingWildcard: (node: any) => boolean;
+}
+export interface WildcardTypeBuildNode {
+    type: 'wildcard';
+    value: string;
+}
+export interface NodeTypes {
+    function: FunctionType;
+    literal: LiteralType;
+    namedArg: NamedArgType;
+    wildcard: WildcardType;
+}
+export {};

package/dist/components/query_bar/querylanguage/kuery/node_types/wildcard.d.ts

@@ -0,0 +1,8 @@
+import { WildcardTypeBuildNode } from './types';
+import { KueryNode } from '..';
+export declare const wildcardSymbol = "@kuery-wildcard@";
+export declare function buildNode(value: string): WildcardTypeBuildNode | KueryNode;
+export declare function test(node: any, str: string): boolean;
+export declare function toOpenSearchQuery(node: any): string;
+export declare function toQueryStringQuery(node: any): string;
+export declare function hasLeadingWildcard(node: any): boolean;

package/dist/components/query_bar/querylanguage/kuery/types.d.ts

@@ -0,0 +1,18 @@
+import { NodeTypes } from './node_types';
+export * from './node_types';
+export interface KueryNode {
+    type: keyof NodeTypes;
+    [key: string]: any;
+}
+export type DslQuery = any;
+export interface KueryParseOptions {
+    helpers: {
+        [key: string]: any;
+    };
+    startRule: string;
+    allowLeadingWildcards: boolean;
+    errorOnLuceneSyntax: boolean;
+    cursorSymbol?: string;
+    parseCursor?: boolean;
+}
+export { nodeTypes } from './node_types';

package/dist/components/query_bar/querylanguage/outputTypes/toCQL.d.ts

@@ -0,0 +1,14 @@
+import { FieldTypes, KueryNode } from '../..';
+export declare const KQL_WILDCARD_SYMBOL = "@kuery-wildcard@";
+export declare const KQL_NODE_TYPE_WILDCARD = "wildcard";
+export type FunctionName = 'is' | 'and' | 'or' | 'not' | 'range' | 'exists' | 'nested';
+export declare const functions: {
+    is: (node: KueryNode, fields?: FieldTypes[]) => string;
+    and: (node: KueryNode, fields?: FieldTypes[]) => string;
+    or: (node: KueryNode, fields?: FieldTypes[]) => string;
+    not: (node: KueryNode, fields?: FieldTypes[]) => string;
+    range: (node: KueryNode) => string;
+    exists: (node: KueryNode) => string;
+    nested: (node: KueryNode) => string;
+};
+export declare const toCql: (node: KueryNode, fields?: FieldTypes[]) => string;

package/dist/components/query_bar/querylanguage/outputTypes/toMongo.d.ts

@@ -0,0 +1,20 @@
+import { FieldTypes, KueryNode } from '../..';
+export declare const KQL_WILDCARD_SYMBOL = "@kuery-wildcard@";
+export declare const KQL_NODE_TYPE_WILDCARD = "wildcard";
+export type FunctionName = 'is' | 'and' | 'or' | 'not' | 'range' | 'exists' | 'nested';
+export declare const functions: {
+    is: (node: KueryNode) => any;
+    and: (node: KueryNode) => any;
+    or: (node: KueryNode) => {
+        $or: any;
+    };
+    not: (node: KueryNode) => any;
+    range: (node: KueryNode) => any;
+    exists: (node: KueryNode) => {
+        [x: string]: {
+            $ne: null;
+        };
+    };
+    nested: (node: KueryNode) => string;
+};
+export declare const toMongo: (node: KueryNode, fields?: FieldTypes[]) => string;

package/dist/components/query_bar/querylanguage/utils.d.ts

@@ -0,0 +1 @@
+export declare function getTimeZoneFromSettings(dateFormatTZ: string): string;

package/dist/components/query_bar/types.d.ts

@@ -0,0 +1,56 @@
+import { NodeTypes } from './querylanguage/kuery/node_types';
+export interface KueryNode {
+    type: keyof NodeTypes;
+    [key: string]: any;
+}
+export type DslQuery = any;
+export interface KueryParseOptions {
+    helpers: {
+        [key: string]: any;
+    };
+    startRule: string;
+    allowLeadingWildcards: boolean;
+    errorOnLuceneSyntax: boolean;
+    cursorSymbol?: string;
+    parseCursor?: boolean;
+}
+export type IIndexPattern = {
+    fields: IFieldType[];
+};
+export interface JsonArray extends Array<JsonValue> {
+}
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonValue = null | boolean | number | string | JsonObject | JsonArray;
+export { nodeTypes } from './querylanguage/kuery/node_types';
+export interface IFieldSubType {
+    multi?: {
+        parent: string;
+    };
+    nested?: {
+        path: string;
+    };
+}
+export interface IFieldType {
+    name: string;
+    type: string;
+    script?: string;
+    lang?: string;
+    count?: number;
+    esTypes?: string[];
+    aggregatable?: boolean;
+    filterable?: boolean;
+    searchable?: boolean;
+    sortable?: boolean;
+    visualizable?: boolean;
+    readFromDocValues?: boolean;
+    scripted?: boolean;
+    subType?: IFieldSubType;
+    displayName?: string;
+    format?: any;
+}
+export interface LatLon {
+    lat: number;
+    lon: number;
+}

package/dist/components/splitview/index.d.ts

@@ -0,0 +1 @@
+export * from './splitview';

package/dist/components/splitview/splitview.css.d.ts

@@ -0,0 +1 @@
+export declare const style: import('lit').CSSResult;