survey-core 1.12.21 → 1.12.22

package/typings/src/expressions/expressions.d.ts

@@ -0,0 +1,135 @@
+import { HashTable } from "../helpers";
+import { ProcessValue } from "../conditionProcessValue";
+export interface AsyncFunctionItem {
+    operand?: FunctionOperand;
+    parent?: AsyncFunctionItem;
+    children?: Array<AsyncFunctionItem>;
+}
+export declare abstract class Operand {
+    private static counter;
+    private _id;
+    get id(): number;
+    toString(func?: (op: Operand) => string): string;
+    abstract getType(): string;
+    abstract evaluate(processValue?: ProcessValue): any;
+    abstract setVariables(variables: Array<string>): any;
+    hasFunction(): boolean;
+    hasAsyncFunction(): boolean;
+    addToAsyncList(list: Array<AsyncFunctionItem>): void;
+    isEqual(op: Operand): boolean;
+    protected abstract isContentEqual(op: Operand): boolean;
+    protected areOperatorsEquals(op1: Operand, op2: Operand): boolean;
+}
+export declare class BinaryOperand extends Operand {
+    private operatorName;
+    private left;
+    private right;
+    private consumer;
+    private isArithmeticValue;
+    constructor(operatorName: string, left?: any, right?: any, isArithmeticOp?: boolean);
+    private get requireStrictCompare();
+    private getIsOperandRequireStrict;
+    getType(): string;
+    get isArithmetic(): boolean;
+    get isConjunction(): boolean;
+    get conjunction(): string;
+    get operator(): string;
+    get leftOperand(): any;
+    get rightOperand(): any;
+    protected isContentEqual(op: Operand): boolean;
+    private evaluateParam;
+    evaluate(processValue?: ProcessValue): any;
+    toString(func?: (op: Operand) => string): string;
+    setVariables(variables: Array<string>): void;
+    hasFunction(): boolean;
+    hasAsyncFunction(): boolean;
+    addToAsyncList(list: Array<AsyncFunctionItem>): void;
+}
+export declare class UnaryOperand extends Operand {
+    private expressionValue;
+    private operatorName;
+    private consumer;
+    constructor(expressionValue: Operand, operatorName: string);
+    get operator(): string;
+    get expression(): Operand;
+    getType(): string;
+    toString(func?: (op: Operand) => string): string;
+    protected isContentEqual(op: Operand): boolean;
+    hasFunction(): boolean;
+    hasAsyncFunction(): boolean;
+    addToAsyncList(list: Array<AsyncFunctionItem>): void;
+    evaluate(processValue?: ProcessValue): boolean;
+    setVariables(variables: Array<string>): void;
+}
+export declare class ArrayOperand extends Operand {
+    values: Array<Operand>;
+    constructor(values: Array<Operand>);
+    getType(): string;
+    toString(func?: (op: Operand) => string): string;
+    evaluate(processValue?: ProcessValue): Array<any>;
+    setVariables(variables: Array<string>): void;
+    hasFunction(): boolean;
+    hasAsyncFunction(): boolean;
+    addToAsyncList(list: Array<AsyncFunctionItem>): void;
+    protected isContentEqual(op: Operand): boolean;
+}
+export declare class Const extends Operand {
+    private value;
+    constructor(value: any);
+    getType(): string;
+    toString(func?: (op: Operand) => string): string;
+    get correctValue(): any;
+    get requireStrictCompare(): boolean;
+    evaluate(): any;
+    setVariables(variables: Array<string>): void;
+    protected getCorrectValue(value: any): any;
+    protected isContentEqual(op: Operand): boolean;
+    private isQuote;
+}
+export declare class Variable extends Const {
+    private variableName;
+    static get DisableConversionChar(): string;
+    static set DisableConversionChar(val: string);
+    private valueInfo;
+    private useValueAsItIs;
+    constructor(variableName: string);
+    get requireStrictCompare(): boolean;
+    getType(): string;
+    toString(func?: (op: Operand) => string): string;
+    get variable(): string;
+    evaluate(processValue?: ProcessValue): any;
+    setVariables(variables: Array<string>): void;
+    protected getCorrectValue(value: any): any;
+    protected isContentEqual(op: Operand): boolean;
+}
+export declare class FunctionOperand extends Operand {
+    private originalValue;
+    private parameters;
+    constructor(originalValue: string, parameters: ArrayOperand);
+    getType(): string;
+    evaluate(processValue?: ProcessValue): any;
+    private evaluateCore;
+    toString(func?: (op: Operand) => string): string;
+    setVariables(variables: Array<string>): void;
+    isReady(proccessValue: ProcessValue): boolean;
+    private getAsynValue;
+    hasFunction(): boolean;
+    hasAsyncFunction(): boolean;
+    private isAsyncFunction;
+    addToAsyncList(list: Array<AsyncFunctionItem>): void;
+    protected isContentEqual(op: Operand): boolean;
+}
+export declare class OperandMaker {
+    static throwInvalidOperatorError(op: string): void;
+    static safeToString(operand: Operand, func: (op: Operand) => string): string;
+    static toOperandString(value: string): string;
+    static isBooleanValue(value: string): boolean;
+    static countDecimals(value: number): number;
+    static plusMinus(a: number, b: number, res: number): number;
+    static unaryFunctions: HashTable<Function>;
+    static binaryFunctions: HashTable<Function>;
+    static isTwoValueEquals(x: any, y: any, ignoreOrder?: boolean): boolean;
+    static operatorToString(operatorName: string): string;
+    static convertValForDateCompare(val: any, second: any): any;
+    static signs: HashTable<string>;
+}

package/typings/src/flowpanel.d.ts

@@ -0,0 +1,34 @@
+import { IElement } from "./base-interfaces";
+import { PanelModel } from "./panel";
+import { LocalizableString } from "./localizablestring";
+import { Question } from "./question";
+/**
+ * The flow panel object. It is a container with flow layout where you can mix questions with markdown text.
+ *
+ */
+export declare class FlowPanelModel extends PanelModel {
+    static contentElementNamePrefix: string;
+    contentChangedCallback: () => void;
+    onGetHtmlForQuestion: (question: Question) => string;
+    onCustomHtmlProducing: () => string;
+    constructor(name?: string);
+    getType(): string;
+    getChildrenLayoutType(): string;
+    onSurveyLoad(): any;
+    get content(): string;
+    set content(val: string);
+    get locContent(): LocalizableString;
+    get html(): string;
+    set html(val: string);
+    protected onContentChanged(): any;
+    produceHtml(): string;
+    getQuestionFromText(str: string): Question;
+    protected getHtmlForQuestion(question: Question): string;
+    protected getQuestionHtmlId(question: Question): string;
+    protected onAddElement(element: IElement, index: number): void;
+    protected onRemoveElement(element: IElement): void;
+    dragDropMoveElement(src: IElement, target: IElement, targetIndex: number): void;
+    private addElementToContent;
+    private insertTextAtCursor;
+    getElementContentText(element: IElement): string;
+}

package/typings/src/functionsfactory.d.ts

@@ -0,0 +1,14 @@
+import { HashTable } from "./helpers";
+export declare class FunctionFactory {
+    static Instance: FunctionFactory;
+    private functionHash;
+    private isAsyncHash;
+    register(name: string, func: (params: any[], originalParams?: any[]) => any, isAsync?: boolean): void;
+    unregister(name: string): void;
+    hasFunction(name: string): boolean;
+    isAsyncFunction(name: string): boolean;
+    clear(): void;
+    getAll(): Array<string>;
+    run(name: string, params: any[], properties: HashTable<any>, originalParams: any[]): any;
+}
+export declare var registerFunction: (name: string, func: (params: any[], originalParams?: any[]) => any, isAsync?: boolean) => void;

package/typings/src/global_variables_utils.d.ts

@@ -0,0 +1,30 @@
+export declare class DomWindowHelper {
+    static isAvailable(): boolean;
+    static isFileReaderAvailable(): boolean;
+    static getLocation(): Location;
+    static getVisualViewport(): VisualViewport | null;
+    static getInnerWidth(): number;
+    static getInnerHeight(): number;
+    static getWindow(): Window;
+    static hasOwn(propertyName: string): boolean;
+    static getSelection(): Selection | null;
+    static requestAnimationFrame(callback: FrameRequestCallback): number;
+    static addEventListener(type: string, listener: (e?: any) => void): void;
+    static removeEventListener(type: string, listener: (e?: any) => void): void;
+    static matchMedia(mediaQueryString: string): {
+        matches: boolean;
+    } | null;
+}
+export declare class DomDocumentHelper {
+    static isAvailable(): boolean;
+    static getBody(): HTMLElement;
+    static getDocumentElement(): HTMLElement;
+    static getDocument(): Document;
+    static getCookie(): string;
+    static setCookie(newCookie: string): void;
+    static activeElementBlur(): Document;
+    static createElement(tagName: string): HTMLElement;
+    static getComputedStyle(elt: Element): CSSStyleDeclaration;
+    static addEventListener(type: string, listener: (e?: any) => void): void;
+    static removeEventListener(type: string, listener: (e?: any) => void): void;
+}

package/typings/src/header.d.ts

@@ -0,0 +1,87 @@
+import { Base, ArrayChanges } from "./base";
+import { HorizontalAlignment, VerticalAlignment } from "./base-interfaces";
+import { SurveyModel } from "./survey";
+import { ITheme } from "./themes";
+export declare class CoverCell {
+    private cover;
+    private positionX;
+    private positionY;
+    static CLASSNAME: string;
+    private calcRow;
+    private calcColumn;
+    private calcAlignItems;
+    private calcAlignText;
+    private calcJustifyContent;
+    constructor(cover: Cover, positionX: HorizontalAlignment, positionY: VerticalAlignment);
+    get survey(): SurveyModel;
+    get css(): string;
+    get style(): any;
+    get contentStyle(): any;
+    get showLogo(): boolean;
+    get showTitle(): boolean;
+    get showDescription(): boolean;
+    get isEmpty(): boolean;
+    get textAreaWidth(): string;
+}
+export declare class Cover extends Base {
+    private _survey;
+    private calcBackgroundSize;
+    private updateHeaderClasses;
+    private updateContentClasses;
+    private updateBackgroundImageClasses;
+    fromTheme(theme: ITheme): void;
+    private init;
+    constructor();
+    getType(): string;
+    cells: CoverCell[];
+    actualHeight: number;
+    height: number;
+    mobileHeight: number;
+    inheritWidthFrom: "survey" | "container";
+    textAreaWidth: number;
+    textGlowEnabled: boolean;
+    overlapEnabled: boolean;
+    backgroundColor: string;
+    titleColor: string;
+    descriptionColor: string;
+    backgroundImage: string;
+    renderBackgroundImage: string;
+    backgroundImageFit: "cover" | "fill" | "contain" | "tile";
+    backgroundImageOpacity: number;
+    logoPositionX: HorizontalAlignment;
+    logoPositionY: VerticalAlignment;
+    titlePositionX: HorizontalAlignment;
+    titlePositionY: VerticalAlignment;
+    descriptionPositionX: HorizontalAlignment;
+    descriptionPositionY: VerticalAlignment;
+    logoStyle: {
+        gridColumn: number;
+        gridRow: number;
+    };
+    titleStyle: {
+        gridColumn: number;
+        gridRow: number;
+    };
+    descriptionStyle: {
+        gridColumn: number;
+        gridRow: number;
+    };
+    headerClasses: string;
+    contentClasses: string;
+    maxWidth: string;
+    backgroundImageClasses: string;
+    get renderedHeight(): string;
+    get renderedTextAreaWidth(): string;
+    get isEmpty(): boolean;
+    get survey(): SurveyModel;
+    set survey(newValue: SurveyModel);
+    get backgroundImageStyle(): {
+        opacity: number;
+        backgroundImage: string;
+        backgroundSize: string;
+    };
+    protected propertyValueChanged(name: string, oldValue: any, newValue: any, arrayChanges?: ArrayChanges, target?: Base): void;
+    calculateActualHeight(logoHeight: number, titleHeight: number, descriptionHeight: number): number;
+    processResponsiveness(width: number): void;
+    get hasBackground(): boolean;
+}

package/typings/src/helpers.d.ts

@@ -0,0 +1,44 @@
+export interface HashTable<T = any> {
+    [key: string]: T;
+}
+export declare function createDate(reason: string, val?: number | string | Date): Date;
+export declare class Helpers {
+    /**
+     * A static methods that returns true if a value undefined, null, empty string or empty array.
+     * @param value
+     */
+    static isValueEmpty(value: any): boolean;
+    static isArrayContainsEqual(x: any, y: any): boolean;
+    static isArraysEqual(x: any, y: any, ignoreOrder?: boolean, caseSensitive?: boolean, trimStrings?: boolean): boolean;
+    static compareStrings(x: string, y: string): number;
+    static isTwoValueEquals(x: any, y: any, ignoreOrder?: boolean, caseSensitive?: boolean, trimStrings?: boolean): boolean;
+    static randomizeArray<T>(array: Array<T>): Array<T>;
+    static getUnbindValue(value: any): any;
+    static createCopy(obj: any): any;
+    static isConvertibleToNumber(value: any): boolean;
+    static isValueObject(val: any, excludeArray?: boolean): boolean;
+    static isNumber(value: any): boolean;
+    static getNumber(value: any): number;
+    private static getNumberCore;
+    private static isStringHasOperator;
+    private static prepareStringToNumber;
+    static getMaxLength(maxLength: number, surveyLength: number): any;
+    static getRemainingCharacterCounterText(newValue: string | undefined, maxLength: number | null): string;
+    static getNumberByIndex(index: number, startIndexStr: string, parentIndex?: number): string;
+    static isCharNotLetterAndDigit(ch: string): boolean;
+    static isCharDigit(ch: string): boolean;
+    static isDigitsOnly(str: string): boolean;
+    private static getNumberFromStr;
+    private static countDecimals;
+    static correctAfterPlusMinis(a: number, b: number, res: number): number;
+    static sumAnyValues(a: any, b: any): any;
+    static correctAfterMultiple(a: number, b: number, res: number): number;
+    static convertArrayValueToObject(src: Array<any>, propName: string, dest?: Array<any>): Array<any>;
+    private static findObjByPropValue;
+    static convertArrayObjectToValue(src: Array<any>, propName: string): Array<any>;
+    static convertDateToString(date: Date): string;
+    static convertDateTimeToString(date: Date): string;
+    static convertValToQuestionVal(val: any, inputType?: string): any;
+    static compareVerions(ver1: string, ver2: string): number;
+    static isUrlYoutubeVideo(url: string): boolean;
+}

package/typings/src/itemvalue.d.ts

@@ -0,0 +1,93 @@
+import { ILocalizableOwner, LocalizableString } from "./localizablestring";
+import { ConditionRunner } from "./conditions";
+import { IShortcutText, ISurvey } from "./base-interfaces";
+import { BaseAction } from "./actions/action";
+/**
+ * Array of ItemValue is used in checkbox, dropdown and radiogroup choices, matrix columns and rows.
+ * It has two main properties: value and text. If text is empty, value is used for displaying.
+ * The text property is localizable and support markdown.
+ */
+export declare class ItemValue extends BaseAction implements ILocalizableOwner, IShortcutText {
+    protected typeName: string;
+    [index: string]: any;
+    getMarkdownHtml(text: string, name: string): string;
+    getRenderer(name: string): string;
+    getRendererContext(locStr: LocalizableString): any;
+    getProcessedText(text: string): string;
+    static get Separator(): string;
+    static set Separator(val: string);
+    /**
+     * Resets the input array and fills it with values from the values array
+     */
+    static setData(items: Array<ItemValue>, values: Array<any>, type?: string): void;
+    static getData(items: Array<ItemValue>): any;
+    static getItemByValue(items: Array<ItemValue>, val: any): ItemValue;
+    static getTextOrHtmlByValue(items: Array<ItemValue>, val: any): string;
+    static locStrsChanged(items: Array<ItemValue>): void;
+    static runConditionsForItems(items: Array<ItemValue>, filteredItems: Array<ItemValue>, runner: ConditionRunner, values: any, properties: any, useItemExpression?: boolean, onItemCallBack?: (item: ItemValue, val: boolean) => boolean): boolean;
+    static runEnabledConditionsForItems(items: Array<ItemValue>, runner: ConditionRunner, values: any, properties: any, onItemCallBack?: (item: ItemValue, val: boolean) => boolean): boolean;
+    private static runConditionsForItemsCore;
+    ownerPropertyName: string;
+    private _visible;
+    private locTextValue;
+    private visibleConditionRunner;
+    private enableConditionRunner;
+    constructor(value: any, text?: string, typeName?: string);
+    onCreating(): any;
+    getType(): string;
+    getSurvey(live?: boolean): ISurvey;
+    getLocale(): string;
+    isGhost: boolean;
+    protected get isInternal(): boolean;
+    get locText(): LocalizableString;
+    setLocText(locText: LocalizableString): void;
+    private _locOwner;
+    get locOwner(): ILocalizableOwner;
+    set locOwner(value: ILocalizableOwner);
+    get value(): any;
+    set value(newValue: any);
+    private setValue;
+    get hasText(): boolean;
+    get pureText(): string;
+    set pureText(val: string);
+    get text(): string;
+    set text(newText: string);
+    get calculatedText(): string;
+    get shortcutText(): string;
+    private canSerializeValue;
+    getData(): any;
+    toJSON(): any;
+    setData(value: any, isNewItem?: boolean): void;
+    get visibleIf(): string;
+    set visibleIf(val: string);
+    get enableIf(): string;
+    set enableIf(val: string);
+    get isVisible(): boolean;
+    setIsVisible(val: boolean): void;
+    get isEnabled(): boolean;
+    setIsEnabled(val: boolean): void;
+    addUsedLocales(locales: Array<string>): void;
+    locStrsChanged(): void;
+    protected onPropertyValueChanged(name: string, oldValue: any, newValue: any): void;
+    protected getConditionRunner(isVisible: boolean): ConditionRunner;
+    private getVisibleConditionRunner;
+    private getEnableConditionRunner;
+    originalItem: any;
+    selectedValue: boolean;
+    get selected(): boolean;
+    private componentValue;
+    getComponent(): string;
+    setComponent(val: string): void;
+    private _htmlElement;
+    setRootElement(val: HTMLElement): void;
+    getRootElement(): HTMLElement;
+    protected getEnabled(): boolean;
+    protected setEnabled(val: boolean): void;
+    protected getVisible(): boolean;
+    protected setVisible(val: boolean): void;
+    protected getLocTitle(): LocalizableString;
+    protected getTitle(): string;
+    protected setLocTitle(val: LocalizableString): void;
+    protected setTitle(val: string): void;
+    icon: string;
+}