@voicenter-team/voicenter-ui-plus 2.0.1 → 2.0.3

package/library/core/types/components/exports.d.ts

@@ -66,7 +66,11 @@ import VcHyperLink from './VcHyperLink/VcHyperLink.vue';
 import VcIconPicker from './VcIconPicker/VcIconPicker.vue';
 import VcMeterGroup from './VcMeterGroup/VcMeterGroup.vue';
 import VcMeterGroupLabel from './VcMeterGroup/VcMeterGroupLabel.vue';
-export { VcButton, VcButtonIcon, VcToggleButton, VcInput, VcInputNumber, VcInputError, VcInputLabel, VcSelect, VcSelectGrouped, VcSelectOption, VcInfiniteScrollSelect, VcAutocomplete, VcCheckbox, VcCheckboxGroup, VcRadio, VcRadioGroup, VcRadioButtonsGroup, VcSwitch, VcSlider, VcColorPicker, VcDatePicker, VcDatePickerPanel, VcDatetimeRangePicker, VcExtendedDatetimeRangePicker, VcTimeInput, VcPhoneInput, VcTagInput, VcOtpInput, VcFileUploader, VcCard, VcModal, VcConfirmModal, VcPopover, VcConfirmPopover, VcSelectPopover, VcTabs, VcTabNav, VcTabPane, VcVerticalTabs, VcRadioTabs, VcRadioTabsNav, VcCollapse, VcCollapseItem, VcWizard, VcDropdown, VcDropdownItem, VcTable, VcPagination, VcTree, VcTreeSelect, VcTransfer, VcTag, VcDelimitedList, VcSparkline, VcViewSwitcher, VcSegmented, VcLoading, VcProgress, VcProgressCircular, VcSkeletonLoader, VcNotification, VcForm, VcFormItem, VcSplitButton, VcHyperLink, VcIconPicker, VcMeterGroup, VcMeterGroupLabel, };
+import VcMdEditor from './VcMdEditor/VcMdEditor.vue';
+import VcSystemUserPrompt from './VcSystemUserPrompt/VcSystemUserPrompt.vue';
+import VcSoundPlayer from './VcSoundplayer/VcSoundPlayer.vue';
+import VcJsonSchema from './VcJsonSchema/VcJsonSchema.vue';
+export { VcButton, VcButtonIcon, VcToggleButton, VcInput, VcInputNumber, VcInputError, VcInputLabel, VcSelect, VcSelectGrouped, VcSelectOption, VcInfiniteScrollSelect, VcAutocomplete, VcCheckbox, VcCheckboxGroup, VcRadio, VcRadioGroup, VcRadioButtonsGroup, VcSwitch, VcSlider, VcColorPicker, VcDatePicker, VcDatePickerPanel, VcDatetimeRangePicker, VcExtendedDatetimeRangePicker, VcTimeInput, VcPhoneInput, VcTagInput, VcOtpInput, VcFileUploader, VcCard, VcModal, VcConfirmModal, VcPopover, VcConfirmPopover, VcSelectPopover, VcTabs, VcTabNav, VcTabPane, VcVerticalTabs, VcRadioTabs, VcRadioTabsNav, VcCollapse, VcCollapseItem, VcWizard, VcDropdown, VcDropdownItem, VcTable, VcPagination, VcTree, VcTreeSelect, VcTransfer, VcTag, VcDelimitedList, VcSparkline, VcViewSwitcher, VcSegmented, VcLoading, VcProgress, VcProgressCircular, VcSkeletonLoader, VcNotification, VcForm, VcFormItem, VcSplitButton, VcHyperLink, VcIconPicker, VcMeterGroup, VcMeterGroupLabel, VcMdEditor, VcSystemUserPrompt, VcSoundPlayer, VcJsonSchema, };
 declare module '@vue/runtime-core' {
     interface GlobalComponents {
         VcButton: typeof VcButton;
@@ -137,5 +141,9 @@ declare module '@vue/runtime-core' {
         VcIconPicker: typeof VcIconPicker;
         VcMeterGroup: typeof VcMeterGroup;
         VcMeterGroupLabel: typeof VcMeterGroupLabel;
+        VcMdEditor: typeof VcMdEditor;
+        VcSystemUserPrompt: typeof VcSystemUserPrompt;
+        VcSoundPlayer: typeof VcSoundPlayer;
+        VcJsonSchema: typeof VcJsonSchema;
     }
 }

package/library/core/types/composables/useCopyButton.d.ts

@@ -0,0 +1,5 @@
+export default function (): {
+    copyTextAction: import("vue").Ref<string, string>;
+    copyDisabled: import("vue").Ref<boolean, boolean>;
+    onCopyHandler: (data: string) => void;
+};

package/library/core/types/entry.d.ts

@@ -29,4 +29,6 @@ export { default as useConfirmPopup, confirmPopupState } from './composables/use
 export { formatDate, parseDate, addDays, subtractDays, getHours, getMinutes, getSeconds, setTime, isAfter, isSameAfter, isBefore, isSameBefore, format, add, sub, addFp, subFp } from './utils/dateTime';
 export { useRTL } from './composables/useRTL';
 export type { RTLState } from './types';
+export * from './components/VcSoundplayer/soundPlayerParts';
+export { buildMustacheSnippet } from './components/VcMdEditor/mdEditor.config';
 export default install;

package/library/core/types/tokens/tokens.d.ts

@@ -1,6 +1,7 @@
 import { InjectionKey } from 'vue';
-import { RTLState, VcCollapseProvideType, VcTabPaneProvideType, VcTabsProvideType } from '../types';
+import { RTLState, VcCollapseProvideType, VcTabPaneProvideType, VcTabsProvideType, VcSoundPlayerProvideType } from '../types';
 export declare const VcCollapseProvideKey: InjectionKey<VcCollapseProvideType>;
 export declare const VcTabsProvideKey: InjectionKey<VcTabsProvideType>;
 export declare const VcTabPaneProvideKey: InjectionKey<VcTabPaneProvideType>;
 export declare const VcRTLToken: InjectionKey<RTLState>;
+export declare const VcSoundPlayerProvideKey: InjectionKey<VcSoundPlayerProvideType>;

package/library/core/types/types/VcMdEditor.types.d.ts

@@ -0,0 +1,12 @@
+import type { ObjectAnyType } from './basic.types';
+export type TMDEditorParameterItem = {
+    label: string;
+    tag: string;
+    description?: string;
+    schema?: ObjectAnyType;
+};
+export type BlockValidationIssue = {
+    tag: string;
+    line: number;
+    type: 'unclosed' | 'unopened';
+};

package/library/core/types/types/VcSoundPlayer.types.d.ts

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+import { WaveSurferOptions } from 'wavesurfer.js';
+export declare type VcSoundPlayerSize = 'sm' | 'md';
+export declare type VcSoundDownloads = Array<string>;
+export declare type VcSoundPlayerProvideType = {
+    componentId: string;
+    options?: Ref<WaveSurferOptions>;
+    isInitialized?: Ref<boolean>;
+    loading?: Ref<boolean>;
+    isPlaying?: Ref<boolean>;
+    isInitSound?: Ref<boolean>;
+    showReset?: Ref<boolean>;
+    duration?: Ref<number>;
+    speed?: Ref<number>;
+    currentTime?: Ref<number>;
+    volume?: Ref<number>;
+    defaultVolume?: () => number;
+    isPlayingInProgress?: Ref<boolean>;
+    initWavesurfer?: (id: string, el?: HTMLElement) => void;
+    play?: () => void;
+    pause?: () => void;
+    stop?: () => void;
+    skipBackward?: (seconds?: number) => void;
+    skipForward?: (seconds?: number) => void;
+    setPlaybackRate?: (speed: number) => void;
+};
+export type HoverPluginOptions = {
+    lineColor?: string;
+    lineWidth?: string | number;
+    labelColor?: string;
+    labelSize?: string | number;
+    labelBackground?: string;
+    formatTimeCallback?: (seconds: number) => string;
+};

package/library/core/types/types/VcSoundPlayerInstance.types.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentExposed } from 'vue-component-type-helpers';
+import type VcSoundPlayer from '../components/VcSoundplayer/VcSoundPlayer.vue';
+import type VcSoundPlayerWrapper from '../components/VcSoundplayer/VcSoundPlayerWrapper.vue';
+export type VcSoundPlayerInstance = ComponentExposed<typeof VcSoundPlayer>;
+export type VcSoundPlayerWrapperInstance = ComponentExposed<typeof VcSoundPlayerWrapper>;
+export type VcSoundPlayerExposed = VcSoundPlayerInstance;
+export type VcSoundPlayerWrapperExposed = VcSoundPlayerWrapperInstance;

package/library/core/types/types/VcSystemUserPrompt.types.d.ts

@@ -0,0 +1,4 @@
+export type TVcSystemUserPromptModel = {
+    system_prompt?: string;
+    user_prompt?: string;
+};

package/library/core/types/types/index.d.ts

@@ -40,3 +40,7 @@ export * from './VueGeneric.types';
 export * from './icons.types';
 export * from './VcSparkline.types';
 export * from './VcTree.types';
+export * from './VcMdEditor.types';
+export * from './VcSystemUserPrompt.types';
+export * from './VcSoundPlayer.types';
+export * from './VcSoundPlayerInstance.types';

package/library/core/types/utils/jsonSchema/helpers.d.ts

@@ -0,0 +1,24 @@
+export default helpers;
+export namespace helpers {
+    export let stringFormats: string[];
+    export { isFormat };
+    export let typeNames: string[];
+    export function getType(val: any): string | undefined;
+    /**
+     * Tries to find the least common schema from two supplied JSON schemas. If it is unable to find
+     * such a schema, it returns null. Incompatibility in structure/types leads to returning null,
+     * except when the difference is only integer/number. Than the 'number' is used instead 'int'.
+     * Types/Structure incompatibility in array items only leads to schema that doesn't specify
+     * items structure/type.
+     * @param {object} schema1 - JSON schema
+     * @param {object} schema2 - JSON schema
+     * @returns {object|null}
+     */
+    export function mergeSchemaObjs(schema1: object, schema2: object): object | null;
+}
+import isEqual from 'lodash/isEqual';
+import xor from 'lodash/xor';
+import keys from 'lodash/keys';
+import merge from 'lodash/merge';
+import { isFormat } from './jsonSchemaHelpers';
+export { isEqual, xor, keys, merge };

package/library/core/types/utils/jsonSchema/index.d.ts

@@ -0,0 +1,44 @@
+export function toJsonSchema(value: any, options: any): object;
+export default ToJsonSchema;
+declare class ToJsonSchema {
+    constructor(options: any);
+    options: any;
+    getObjectSchemaDefault(obj: any): {
+        type: string;
+    };
+    getStringSchemaDefault(value: any): {
+        type: string;
+    };
+    objectPostProcessDefault(schema: any, obj: any): any;
+    commmonPostProcessDefault(type: any, schema: any): any;
+    /**
+     * Tries to find the least common schema that would validate all items in the array. More details
+     * helpers.mergeSchemaObjs description
+     * @param {array} arr
+     * @returns {object|null}
+     */
+    getCommonArrayItemSchema(arr: array): object | null;
+    getObjectSchema(obj: any): any;
+    getArraySchemaMerging(arr: any): {
+        type: string;
+    };
+    getArraySchemaNoMerging(arr: any): {
+        type: string;
+    };
+    getArraySchemaTuple(arr: any): {
+        type: string;
+    };
+    getArraySchemaUniform(arr: any): {
+        type: string;
+    };
+    getArraySchema(arr: any): {
+        type: string;
+    };
+    getStringSchema(value: any): any;
+    /**
+     * Gets JSON schema for provided value
+     * @param value
+     * @returns {object}
+     */
+    getSchema(value: any): object;
+}

package/library/core/types/utils/jsonSchema/jsonSchemaHelpers.d.ts

@@ -0,0 +1,33 @@
+export namespace types {
+    export function string(instance: any): boolean;
+    export function number(instance: any): boolean;
+    export function integer(instance: any): boolean;
+    export function boolean(instance: any): boolean;
+    export function array(instance: any): boolean;
+    export function _null(instance: any): boolean;
+    export { _null as null };
+    export function date(instance: any): boolean;
+    export function any(): boolean;
+    export function object(instance: any): any;
+}
+export const FORMAT_REGEXPS: {
+    'date-time': RegExp;
+    date: RegExp;
+    time: RegExp;
+    email: RegExp;
+    'ip-address': RegExp;
+    ipv6: RegExp;
+    uri: RegExp;
+    color: RegExp;
+    hostname: RegExp;
+    'host-name': RegExp;
+    alpha: RegExp;
+    alphanumeric: RegExp;
+    'utc-millisec': (input: any) => boolean;
+    regex(input: any): boolean;
+    style: RegExp;
+    phone: RegExp;
+};
+export function isFormat(input: any, format: any): any;
+declare const _default: {};
+export default _default;

package/library/core/vb-Dp90gtsv.mjs

@@ -0,0 +1,196 @@
+var ERRORCLASS = "error";
+function wordRegexp(words) {
+  return new RegExp("^((" + words.join(")|(") + "))\\b", "i");
+}
+var singleOperators = new RegExp("^[\\+\\-\\*/%&\\\\|\\^~<>!]");
+var singleDelimiters = new RegExp("^[\\(\\)\\[\\]\\{\\}@,:`=;\\.]");
+var doubleOperators = new RegExp("^((==)|(<>)|(<=)|(>=)|(<>)|(<<)|(>>)|(//)|(\\*\\*))");
+var doubleDelimiters = new RegExp("^((\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
+var tripleDelimiters = new RegExp("^((//=)|(>>=)|(<<=)|(\\*\\*=))");
+var identifiers = new RegExp("^[_A-Za-z][_A-Za-z0-9]*");
+var openingKeywords = ["class", "module", "sub", "enum", "select", "while", "if", "function", "get", "set", "property", "try", "structure", "synclock", "using", "with"];
+var middleKeywords = ["else", "elseif", "case", "catch", "finally"];
+var endKeywords = ["next", "loop"];
+var operatorKeywords = ["and", "andalso", "or", "orelse", "xor", "in", "not", "is", "isnot", "like"];
+var wordOperators = wordRegexp(operatorKeywords);
+var commonKeywords = ["#const", "#else", "#elseif", "#end", "#if", "#region", "addhandler", "addressof", "alias", "as", "byref", "byval", "cbool", "cbyte", "cchar", "cdate", "cdbl", "cdec", "cint", "clng", "cobj", "compare", "const", "continue", "csbyte", "cshort", "csng", "cstr", "cuint", "culng", "cushort", "declare", "default", "delegate", "dim", "directcast", "each", "erase", "error", "event", "exit", "explicit", "false", "for", "friend", "gettype", "goto", "handles", "implements", "imports", "infer", "inherits", "interface", "isfalse", "istrue", "lib", "me", "mod", "mustinherit", "mustoverride", "my", "mybase", "myclass", "namespace", "narrowing", "new", "nothing", "notinheritable", "notoverridable", "of", "off", "on", "operator", "option", "optional", "out", "overloads", "overridable", "overrides", "paramarray", "partial", "private", "protected", "public", "raiseevent", "readonly", "redim", "removehandler", "resume", "return", "shadows", "shared", "static", "step", "stop", "strict", "then", "throw", "to", "true", "trycast", "typeof", "until", "until", "when", "widening", "withevents", "writeonly"];
+var commontypes = ["object", "boolean", "char", "string", "byte", "sbyte", "short", "ushort", "int16", "uint16", "integer", "uinteger", "int32", "uint32", "long", "ulong", "int64", "uint64", "decimal", "single", "double", "float", "date", "datetime", "intptr", "uintptr"];
+var keywords = wordRegexp(commonKeywords);
+var types = wordRegexp(commontypes);
+var stringPrefixes = '"';
+var opening = wordRegexp(openingKeywords);
+var middle = wordRegexp(middleKeywords);
+var closing = wordRegexp(endKeywords);
+var doubleClosing = wordRegexp(["end"]);
+var doOpening = wordRegexp(["do"]);
+function indent(_stream, state) {
+  state.currentIndent++;
+}
+function dedent(_stream, state) {
+  state.currentIndent--;
+}
+function tokenBase(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+  var ch = stream.peek();
+  if (ch === "'") {
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (stream.match(/^((&H)|(&O))?[0-9\.a-f]/i, false)) {
+    var floatLiteral = false;
+    if (stream.match(/^\d*\.\d+F?/i)) {
+      floatLiteral = true;
+    } else if (stream.match(/^\d+\.\d*F?/)) {
+      floatLiteral = true;
+    } else if (stream.match(/^\.\d+F?/)) {
+      floatLiteral = true;
+    }
+    if (floatLiteral) {
+      stream.eat(/J/i);
+      return "number";
+    }
+    var intLiteral = false;
+    if (stream.match(/^&H[0-9a-f]+/i)) {
+      intLiteral = true;
+    } else if (stream.match(/^&O[0-7]+/i)) {
+      intLiteral = true;
+    } else if (stream.match(/^[1-9]\d*F?/)) {
+      stream.eat(/J/i);
+      intLiteral = true;
+    } else if (stream.match(/^0(?![\dx])/i)) {
+      intLiteral = true;
+    }
+    if (intLiteral) {
+      stream.eat(/L/i);
+      return "number";
+    }
+  }
+  if (stream.match(stringPrefixes)) {
+    state.tokenize = tokenStringFactory(stream.current());
+    return state.tokenize(stream, state);
+  }
+  if (stream.match(tripleDelimiters) || stream.match(doubleDelimiters)) {
+    return null;
+  }
+  if (stream.match(doubleOperators) || stream.match(singleOperators) || stream.match(wordOperators)) {
+    return "operator";
+  }
+  if (stream.match(singleDelimiters)) {
+    return null;
+  }
+  if (stream.match(doOpening)) {
+    indent(stream, state);
+    state.doInCurrentLine = true;
+    return "keyword";
+  }
+  if (stream.match(opening)) {
+    if (!state.doInCurrentLine)
+      indent(stream, state);
+    else
+      state.doInCurrentLine = false;
+    return "keyword";
+  }
+  if (stream.match(middle)) {
+    return "keyword";
+  }
+  if (stream.match(doubleClosing)) {
+    dedent(stream, state);
+    dedent(stream, state);
+    return "keyword";
+  }
+  if (stream.match(closing)) {
+    dedent(stream, state);
+    return "keyword";
+  }
+  if (stream.match(types)) {
+    return "keyword";
+  }
+  if (stream.match(keywords)) {
+    return "keyword";
+  }
+  if (stream.match(identifiers)) {
+    return "variable";
+  }
+  stream.next();
+  return ERRORCLASS;
+}
+function tokenStringFactory(delimiter) {
+  var singleline = delimiter.length == 1;
+  var OUTCLASS = "string";
+  return function(stream, state) {
+    while (!stream.eol()) {
+      stream.eatWhile(/[^'"]/);
+      if (stream.match(delimiter)) {
+        state.tokenize = tokenBase;
+        return OUTCLASS;
+      } else {
+        stream.eat(/['"]/);
+      }
+    }
+    if (singleline) {
+      state.tokenize = tokenBase;
+    }
+    return OUTCLASS;
+  };
+}
+function tokenLexer(stream, state) {
+  var style = state.tokenize(stream, state);
+  var current = stream.current();
+  if (current === ".") {
+    style = state.tokenize(stream, state);
+    if (style === "variable") {
+      return "variable";
+    } else {
+      return ERRORCLASS;
+    }
+  }
+  var delimiter_index = "[({".indexOf(current);
+  if (delimiter_index !== -1) {
+    indent(stream, state);
+  }
+  delimiter_index = "])}".indexOf(current);
+  if (delimiter_index !== -1) {
+    if (dedent(stream, state)) {
+      return ERRORCLASS;
+    }
+  }
+  return style;
+}
+const vb = {
+  name: "vb",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      lastToken: null,
+      currentIndent: 0,
+      nextLineIndent: 0,
+      doInCurrentLine: false
+    };
+  },
+  token: function(stream, state) {
+    if (stream.sol()) {
+      state.currentIndent += state.nextLineIndent;
+      state.nextLineIndent = 0;
+      state.doInCurrentLine = 0;
+    }
+    var style = tokenLexer(stream, state);
+    state.lastToken = { style, content: stream.current() };
+    return style;
+  },
+  indent: function(state, textAfter, cx) {
+    var trueText = textAfter.replace(/^\s+|\s+$/g, "");
+    if (trueText.match(closing) || trueText.match(doubleClosing) || trueText.match(middle)) return cx.unit * (state.currentIndent - 1);
+    if (state.currentIndent < 0) return 0;
+    return state.currentIndent * cx.unit;
+  },
+  languageData: {
+    closeBrackets: { brackets: ["(", "[", "{", '"'] },
+    commentTokens: { line: "'" },
+    autocomplete: openingKeywords.concat(middleKeywords).concat(endKeywords).concat(operatorKeywords).concat(commonKeywords).concat(commontypes)
+  }
+};
+export {
+  vb
+};