@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/DrilldownPane.vue.d.ts

@@ -0,0 +1,94 @@
+import { PropType } from 'vue';
+import { CompletionItem } from '../stores/resolver';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    drilldownRemove: {
+        type: StringConstructor;
+        required: true;
+    };
+    drilldownFilter: {
+        type: StringConstructor;
+        required: true;
+    };
+    symbols: {
+        type: PropType<CompletionItem[]>;
+        required: true;
+    };
+}>, {
+    searchQuery: import('vue').Ref<string, string>;
+    filteredDimensions: import('vue').Ref<{
+        label: string;
+        description: string;
+        type: string;
+        datatype: string;
+        insertText: string;
+        trilogyType?: ("concept" | "function" | "type") | undefined;
+        trilogySubType?: ("property" | "key" | "metric") | undefined;
+        calculation?: string | undefined;
+        keys?: string[] | undefined;
+    }[], CompletionItem[] | {
+        label: string;
+        description: string;
+        type: string;
+        datatype: string;
+        insertText: string;
+        trilogyType?: ("concept" | "function" | "type") | undefined;
+        trilogySubType?: ("property" | "key" | "metric") | undefined;
+        calculation?: string | undefined;
+        keys?: string[] | undefined;
+    }[]>;
+    drilldownSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    dimensionsList: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    tooltip: {
+        visible: boolean;
+        x: number;
+        y: number;
+        dimension: {
+            label: string;
+            description: string;
+            type: string;
+            datatype: string;
+            insertText: string;
+            trilogyType?: ("concept" | "function" | "type") | undefined;
+            trilogySubType?: ("property" | "key" | "metric") | undefined;
+            calculation?: string | undefined;
+            keys?: string[] | undefined;
+        };
+    };
+    selected: import('vue').Ref<string[], string[]>;
+    highlightedIndex: import('vue').Ref<number, number>;
+    filterDimensions: () => void;
+    selectDimension: (dimension: CompletionItem) => void;
+    removeDimension: (dimensionLabel: string) => void;
+    handleSubmit: () => void;
+    handleClose: () => void;
+    handleSearchKeydown: (event: KeyboardEvent) => void;
+    setHighlightedIndex: (index: number) => void;
+    getIconType: (dimension: CompletionItem) => string;
+    getIconMdiClass: (dimension: CompletionItem) => string;
+    getDimensionChar: (dimension: CompletionItem) => string;
+    getIconClass: (dimension: CompletionItem) => string;
+    getIconTooltip: (dimension: CompletionItem) => string;
+    showTooltip: (event: MouseEvent, dimension: CompletionItem) => Promise<void>;
+    hideTooltip: () => void;
+    updateTooltipPosition: (event: MouseEvent) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close" | "submit" | "select-dimension" | "remove-dimension")[], "close" | "submit" | "select-dimension" | "remove-dimension", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    drilldownRemove: {
+        type: StringConstructor;
+        required: true;
+    };
+    drilldownFilter: {
+        type: StringConstructor;
+        required: true;
+    };
+    symbols: {
+        type: PropType<CompletionItem[]>;
+        required: true;
+    };
+}>> & Readonly<{
+    onSubmit?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+    "onSelect-dimension"?: ((...args: any[]) => any) | undefined;
+    "onRemove-dimension"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=DrilldownPane.vue.d.ts.map

package/dist/components/DrilldownPane.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrilldownPane.vue.d.ts","sourceRoot":"","sources":["../../components/DrilldownPane.vue"],"names":[],"mappings":"AAiJA;AAshCA,OAAO,EAGL,KAAK,QAAQ,EAMd,MAAM,KAAK,CAAA;AAEZ,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;;;;;;;;;;;cA6BnC,QAAQ,CAAC,cAAc,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA0Hd,IAAI;iCA0EG,cAAc;sCA0BT,MAAM;;;iCAlKX,aAAa;iCAyDb,MAAM;6BA4CV,cAAc,KAAG,MAAM;iCAMnB,cAAc,KAAG,MAAM;kCAOtB,cAAc,KAAG,MAAM;8BAK3B,cAAc,KAAG,MAAM;gCAOrB,cAAc,KAAG,MAAM;yBAgExB,UAAU,aAAa,cAAc;;mCA+BjC,UAAU;;;;;;;;;;;cAzR/B,QAAQ,CAAC,cAAc,EAAE,CAAC;;;;;;;;;AAZ/C,wBA0WC"}

package/dist/components/EditableTitle.vue.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    testId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    isEditing: import('vue').Ref<boolean, boolean>;
+    editableName: import('vue').Ref<string, string>;
+    nameInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    startEditing: () => void;
+    finishEditing: () => void;
+    cancelEditing: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    testId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    testId: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=EditableTitle.vue.d.ts.map

package/dist/components/EditableTitle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditableTitle.vue.d.ts","sourceRoot":"","sources":["../../components/EditableTitle.vue"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4HA,wBAiDC"}

package/dist/components/ErrorMessage.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    type: {
+        type: () => "error" | "information";
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}>, {}, {}, {
+    messageClass(): string;
+    iconEmoji(): string;
+}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    type: {
+        type: () => "error" | "information";
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}>> & Readonly<{}>, {
+    type: "error" | "information";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ErrorMessage.vue.d.ts.map

package/dist/components/ErrorMessage.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorMessage.vue.d.ts","sourceRoot":"","sources":["../../components/ErrorMessage.vue"],"names":[],"mappings":"AAWA;;;cAuFsB,MAAM,OAAO,GAAG,aAAa;;2BAE1B,MAAM;;;oBAIX,MAAM;iBAGT,MAAM;;;cATD,MAAM,OAAO,GAAG,aAAa;;2BAE1B,MAAM;;;;;AAN/B,wBAkBC"}

package/dist/components/HighlightComponent.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    type: 'tip' | 'warning' | 'caution';
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=HighlightComponent.vue.d.ts.map

package/dist/components/HighlightComponent.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HighlightComponent.vue.d.ts","sourceRoot":"","sources":["../../components/HighlightComponent.vue"],"names":[],"mappings":"AAKA;AAuCA,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,KAAK,GAAG,SAAS,GAAG,SAAS,CAAA;CAAE,CAAC;AAK3D,iBAAS,cAAc;WA8BT,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AAQD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,6SAOnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/HintComponent.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    staticShortcuts: {
+        name: string;
+        keys: string[];
+    }[];
+    sysType: string;
+}, {
+    shortcuts(): Array<any>;
+    icon(): "⌘" | "Ctrl";
+}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=HintComponent.vue.d.ts.map

package/dist/components/HintComponent.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HintComponent.vue.d.ts","sourceRoot":"","sources":["../../components/HintComponent.vue"],"names":[],"mappings":"AA8DA;;;;;;;;iBA2QiB,KAAK,CAAC,GAAG,CAAC;;;AArD3B,wBAwEC"}

package/dist/components/InlineErrorMessage.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=InlineErrorMessage.vue.d.ts.map

package/dist/components/InlineErrorMessage.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineErrorMessage.vue.d.ts","sourceRoot":"","sources":["../../components/InlineErrorMessage.vue"],"names":[],"mappings":"AASA;;AAmDA,wBAIC"}

package/dist/components/LoadingButton.vue.d.ts

@@ -0,0 +1,121 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    action: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    useDefaultStyle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyCombination: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: null;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    testId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    errorMessage: import('vue').Ref<string | null, string | null>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+    handleClick: () => Promise<void>;
+    handleKeydown: (event: KeyboardEvent) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    action: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    useDefaultStyle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyCombination: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: null;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    testId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    useDefaultStyle: boolean;
+    keyCombination: string[];
+    testId: string;
+}, {}, {
+    Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        visible: boolean;
+        hoverTimeout: ReturnType<typeof setTimeout> | null;
+    }, {
+        positionClass(): string;
+    }, {
+        showTooltip(): void;
+        hideTooltip(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        position: string;
+        inline: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=LoadingButton.vue.d.ts.map

package/dist/components/LoadingButton.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingButton.vue.d.ts","sourceRoot":"","sources":["../../components/LoadingButton.vue"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA2OkC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhC/C,wBAiGC"}

package/dist/components/LoadingView.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: import('vue').DefineComponent<{
+    cancel?: ((() => void) | null) | undefined;
+    text: string;
+    startTime: number | null;
+}, {
+    containerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    containerHeight: import('vue').Ref<number, number>;
+    handleCancel: () => void;
+    trilogyIcon: string;
+    elapsedTime: import('vue').Ref<string, string>;
+    isCompact: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    cancel?: ((() => void) | null) | undefined;
+    text: string;
+    startTime: number | null;
+}> & Readonly<{}>, {
+    text: string;
+    startTime: number | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=LoadingView.vue.d.ts.map

package/dist/components/LoadingView.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoadingView.vue.d.ts","sourceRoot":"","sources":["../../components/LoadingView.vue"],"names":[],"mappings":"AAiBA;;cA6OW,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;UACtB,MAAM;eACD,MAAM,GAAG,IAAI;;;;;;;;;cAFf,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;UACtB,MAAM;eACD,MAAM,GAAG,IAAI;;;;;AAG1B,wBAsGC"}

package/dist/components/MarkdownRenderer.vue.d.ts

@@ -0,0 +1,39 @@
+import { PropType } from 'vue';
+import { Results } from '../editors/results';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    results: {
+        type: PropType<Results | null>;
+        default: null;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    renderedMarkdown: import('vue').ComputedRef<string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    results: {
+        type: PropType<Results | null>;
+        default: null;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    results: Results | null;
+    loading: boolean;
+    markdown: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=MarkdownRenderer.vue.d.ts.map

package/dist/components/MarkdownRenderer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownRenderer.vue.d.ts","sourceRoot":"","sources":["../../components/MarkdownRenderer.vue"],"names":[],"mappings":"AAKA;AAmRA,OAAO,EAA6B,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;;;;;;;;cAY3B,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;cAAxB,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;;;;;;;;;;;;AAT9C,wBA2BC"}

package/dist/components/PopupModal.vue.d.ts

@@ -0,0 +1,50 @@
+import { ModalItem } from '../data/tips';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    showModal: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    activeItems: {
+        type: () => ModalItem[];
+        default: () => never[];
+    };
+    initialWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    initialHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "mark-item-read": (...args: any[]) => void;
+    "close-modal": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    showModal: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    activeItems: {
+        type: () => ModalItem[];
+        default: () => never[];
+    };
+    initialWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    initialHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onMark-item-read"?: ((...args: any[]) => any) | undefined;
+    "onClose-modal"?: ((...args: any[]) => any) | undefined;
+}>, {
+    initialWidth: number;
+    initialHeight: number;
+    activeItems: ModalItem[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    editorElement: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=PopupModal.vue.d.ts.map

package/dist/components/PopupModal.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PopupModal.vue.d.ts","sourceRoot":"","sources":["../../components/PopupModal.vue"],"names":[],"mappings":"AA+CA;AA0cA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;;;;;;;cAic1B,MAAM,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;cAAjB,MAAM,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;AAZpC,wBA0BG"}