@knime/scripting-editor 0.0.80 → 0.0.82

package/dist/node_modules/@knime/components/src/components/forms/SearchableList/SearchableList.vue.d.ts

@@ -0,0 +1,285 @@
+import { PropType, Ref } from 'vue';
+import { Id, PossibleValue, BottomValue } from '../possibleValues';
+
+declare const _default: import('vue').DefineComponent<{
+    initialCaseSensitiveSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    bottomValue: {
+        type: PropType<BottomValue>;
+        default: () => {
+            id: string;
+            text: string;
+        };
+        validator(value: BottomValue): boolean;
+    };
+    withBottomValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    /**
+     * Controls the size of the list.
+     * Number of visible items (for others user need to scroll)
+     * - 0 means all
+     * - values 1 - 4  are ignored; 5 is minimum
+     */
+    size: {
+        type: NumberConstructor;
+        default: number;
+        validator(value: number): boolean;
+    };
+    alignment: {
+        type: StringConstructor;
+        default: string;
+        validator(value: string): boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: null;
+    };
+    modelValue: {
+        type: PropType<Id[] | null>;
+        default: () => void;
+    };
+    possibleValues: {
+        type: PropType<PossibleValue[]>;
+        default: () => never[];
+    };
+    isValid: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    withSearchLabel: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    showSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Labels
+     */
+    searchLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    initialSearchTerm: {
+        type: StringConstructor;
+        default: string;
+    };
+    showEmptyState: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * Is only used when emptyStateComponent is null
+     */
+    emptyStateLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    /**
+     * this component is displayed centered in the middle of the box in case it is empty
+     */
+    emptyStateComponent: {
+        default: null;
+        type: ObjectConstructor;
+    };
+    filterChosenValuesOnPossibleValuesChange: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: false;
+    };
+    unknownValuesText: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    concatenatedItems: import('vue').ComputedRef<PossibleValue[]>;
+    visibleValues: import('vue').ComputedRef<PossibleValue[]>;
+    selectedValues: Ref<Id[] | null>;
+    searchTerm: Ref<string>;
+    matchingValidIds: import('vue').ComputedRef<PossibleValue[]>;
+    caseSensitiveSearch: Ref<boolean>;
+    invalidValueIds: import('vue').ComputedRef<Id[]>;
+    matchingInvalidValueIds: import('vue').ComputedRef<PossibleValue[]>;
+    numLabelInfos: import('vue').ComputedRef<string>;
+    numMatchedSearchedItems: import('vue').ComputedRef<PossibleValue[]>;
+    possibleValueMap: import('vue').ComputedRef<Record<Id, {
+        item: PossibleValue;
+        index: number;
+    }>>;
+}, unknown, {
+    listSize(): number;
+}, {
+    hasSelection(): boolean;
+    onChange(newVal: Id[]): void;
+    onSearchInput(value: string): void;
+    validate(): {
+        isValid: boolean;
+        errorMessage: string | null;
+    };
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    initialCaseSensitiveSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    bottomValue: {
+        type: PropType<BottomValue>;
+        default: () => {
+            id: string;
+            text: string;
+        };
+        validator(value: BottomValue): boolean;
+    };
+    withBottomValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    /**
+     * Controls the size of the list.
+     * Number of visible items (for others user need to scroll)
+     * - 0 means all
+     * - values 1 - 4  are ignored; 5 is minimum
+     */
+    size: {
+        type: NumberConstructor;
+        default: number;
+        validator(value: number): boolean;
+    };
+    alignment: {
+        type: StringConstructor;
+        default: string;
+        validator(value: string): boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: null;
+    };
+    modelValue: {
+        type: PropType<Id[] | null>;
+        default: () => void;
+    };
+    possibleValues: {
+        type: PropType<PossibleValue[]>;
+        default: () => never[];
+    };
+    isValid: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    withSearchLabel: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    showSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Labels
+     */
+    searchLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    initialSearchTerm: {
+        type: StringConstructor;
+        default: string;
+    };
+    showEmptyState: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * Is only used when emptyStateComponent is null
+     */
+    emptyStateLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    /**
+     * this component is displayed centered in the middle of the box in case it is empty
+     */
+    emptyStateComponent: {
+        default: null;
+        type: ObjectConstructor;
+    };
+    filterChosenValuesOnPossibleValuesChange: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: false;
+    };
+    unknownValuesText: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    size: number;
+    disabled: boolean;
+    id: string;
+    compact: boolean;
+    possibleValues: PossibleValue[];
+    modelValue: Id[] | null;
+    isValid: boolean;
+    ariaLabel: string;
+    emptyStateLabel: string;
+    emptyStateComponent: Record<string, any>;
+    withBottomValue: boolean;
+    bottomValue: BottomValue;
+    showEmptyState: boolean;
+    initialCaseSensitiveSearch: boolean;
+    initialSearchTerm: string;
+    showSearch: boolean;
+    withSearchLabel: boolean;
+    searchLabel: string;
+    searchPlaceholder: string;
+    unknownValuesText: string;
+    filterChosenValuesOnPossibleValuesChange: boolean;
+    alignment: string;
+}, {}>;
+export default _default;

package/dist/node_modules/@knime/components/src/components/forms/SortList/SortList.vue.d.ts

@@ -0,0 +1,26 @@
+import { PossibleValue } from '../possibleValues';
+
+export interface Props {
+    modelValue: string[];
+    id?: string;
+    ariaLabel: string;
+    disabled?: boolean;
+    possibleValues: (PossibleValue & {
+        id: string;
+    })[];
+}
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (args_0: string[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<Props>>> & {
+    "onUpdate:modelValue"?: ((args_0: string[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/node_modules/@knime/components/src/components/forms/Twinlist/Twinlist.vue.d.ts

@@ -0,0 +1,381 @@
+import { PropType, Ref } from 'vue';
+import { Id, PossibleValue } from '../possibleValues';
+
+interface TransformOnMovePayload {
+    /**
+     * The to be updated list of ids
+     */
+    previous: Id[];
+    movingParts: {
+        /**
+         * The moved items that are not the "unknown values"
+         */
+        knownValues: Array<Id>;
+        /**
+         * Whether the unknown values are part of the moved items
+         */
+        movingUnknownValues: boolean;
+    };
+}
+/** The included values or null if not yet known. Values which are not an id in the possible values will be shown as missing. */
+type SimpleTwinlistModelValue<T extends Id> = null | T[];
+/**
+ * using this form of model value allows showing unknown values. With that the logic for missing values also changes:
+ * Missing values on the same side as unknown values are not displayed and removed as soon as the user moves items.
+ * Also missing values now can always exist on the opposite side of the unknown values which is why we also need to
+ *  keep track of the excluded values as data.
+ */
+interface TwinlistModelValueWithUnknownValues<T extends Id> {
+    /**
+     * null if not yet known
+     */
+    includedValues: T[] | null;
+    /**
+     * null if not yet known
+     */
+    excludedValues: T[] | null;
+    includeUnknownValues: boolean;
+}
+type TwinlistModelValue<T extends Id = Id> = SimpleTwinlistModelValue<T> | TwinlistModelValueWithUnknownValues<T>;
+declare const useTwinlistModelValue: (modelValue: Ref<TwinlistModelValue>) => {
+    includedValues: import('vue').ComputedRef<Id[] | null>;
+    excludedValues: import('vue').ComputedRef<Id[] | null>;
+    showUnknownExcludedValues: import('vue').ComputedRef<boolean>;
+    showUnknownIncludedValues: import('vue').ComputedRef<boolean>;
+    getEmitValue: (newIncludedValues: Id[] | null, toNewExcluded?: (oldVal: Id[] | null) => Id[] | null, toNewIncludeUnknownValues?: (oldVal: boolean) => boolean) => TwinlistModelValue;
+};
+export { type TwinlistModelValue, useTwinlistModelValue };
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: PropType<TwinlistModelValue<Id>>;
+        default: null;
+    };
+    initialCaseSensitiveSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    initialSearchTerm: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Hiding and disabling
+     */
+    showSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    disabled: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    showEmptyState: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * Labels
+     */
+    leftLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    rightLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    withSearchLabel: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    searchLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    unknownValuesText: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Is only used when emptyStateComponent is null
+     */
+    emptyStateLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    /**
+     * this component is displayed centered in the middle of the box in case it is empty
+     */
+    emptyStateComponent: {
+        default: null;
+        type: ObjectConstructor;
+    };
+    /**
+     * Controls the size of the list.
+     * Number of visible items (for others user need to scroll)
+     * - 0 means all
+     * - values 1 - 4  are ignored; 5 is minimum
+     */
+    size: {
+        type: NumberConstructor;
+        default: number;
+        validator(value: number): boolean;
+    };
+    isValid: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * List of possible values. Each item must have an `id` and a `text` property
+     * @example
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF'
+     * }, {
+     *   id: 'XLS',
+     *   text: 'Excel',
+     * }]
+     */
+    possibleValues: {
+        type: PropType<PossibleValue[]>;
+        default: () => never[];
+    };
+    /**
+     * If this setting is true, on a change of possible values, the currently
+     * chosen values which are missing with respect to the new possible values
+     * are removed.
+     */
+    filterChosenValuesOnPossibleValuesChange: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: false;
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    includedValues: import('vue').ComputedRef<Id[] | null>;
+    excludedValues: import('vue').ComputedRef<Id[] | null>;
+    showUnknownExcludedValues: import('vue').ComputedRef<boolean>;
+    showUnknownIncludedValues: import('vue').ComputedRef<boolean>;
+    getEmitValue: (newIncludedValues: Id[] | null, toNewExcluded?: (oldVal: Id[] | null) => Id[] | null, toNewIncludeUnknownValues?: (oldVal: boolean) => boolean) => TwinlistModelValue<Id>;
+    searchTerm: Ref<string>;
+    filteredExcludedItems: import('vue').ComputedRef<PossibleValue[]>;
+    filteredIncludedItems: import('vue').ComputedRef<PossibleValue[]>;
+    knownExcludedValues: import('vue').ComputedRef<Id[]>;
+    knownIncludedValues: import('vue').ComputedRef<Id[] | null>;
+    possibleValueIds: import('vue').ComputedRef<Id[]>;
+    possibleValueIdsSet: import('vue').ComputedRef<Set<Id>>;
+    excludedLabels: import('vue').ComputedRef<string | null>;
+    includedLabels: import('vue').ComputedRef<string | null>;
+    caseSensitiveSearch: Ref<boolean>;
+    allIncludedItems: import('vue').ComputedRef<PossibleValue[]>;
+    possibleValueMap: import('vue').ComputedRef<Record<Id, {
+        item: PossibleValue;
+        index: number;
+    }>>;
+}, {
+    invalidPossibleValueIds: Set<unknown>;
+    rightSelected: Id[];
+    leftSelected: Id[];
+    unknownValuesId: symbol;
+}, {
+    listSize(): number;
+    moveAllRightButtonDisabled(): boolean;
+    moveRightButtonDisabled(): boolean;
+    moveAllLeftButtonDisabled(): boolean;
+    moveLeftButtonDisabled(): boolean;
+}, {
+    getIndex(id: Id): number;
+    compareByOriginalSorting(a: Id, b: Id): number;
+    clearSelections(): void;
+    moveItems(items: Id[], { toNewIncludedValues, toNewExcludedValues, }: {
+        toNewIncludedValues: (params: TransformOnMovePayload) => Id[];
+        toNewExcludedValues: (params: TransformOnMovePayload) => Id[];
+    }): void;
+    moveRight(itemsParam?: Id[] | null): void;
+    moveLeft(itemsParam?: Id[] | null): void;
+    /**
+     * Filters out the moved items and also invalid items if unknown values are being moved.
+     */
+    filterMovedItems({ previous, movingParts: { movingUnknownValues, knownValues }, }: TransformOnMovePayload): Id[];
+    /**
+     * Adds the given items sorting by the order in the possible values afterwards and removing invalid items
+     * if unknown values are being moved
+     */
+    addMovedItems({ previous, movingParts: { movingUnknownValues, knownValues }, }: TransformOnMovePayload): Id[];
+    onMoveRightButtonClick(): void;
+    onMoveAllRightButtonClick(): void;
+    onMoveAllRightButtonKey(e: KeyboardEvent): void;
+    onMoveRightButtonKey(e: KeyboardEvent): void;
+    onMoveLeftButtonClick(): void;
+    onMoveAllLeftButtonClick(): void;
+    onMoveLeftButtonKey(e: KeyboardEvent): void;
+    onMoveAllLeftButtonKey(e: KeyboardEvent): void;
+    stopPropagation(e: KeyboardEvent): void;
+    onLeftListBoxDoubleClick(item: Id): void;
+    onLeftListBoxShiftDoubleClick(items: Id[]): void;
+    onRightListBoxDoubleClick(item: Id): void;
+    onRightListBoxShiftDoubleClick(items: Id[]): void;
+    onLeftInput(value: Id[]): void;
+    onRightInput(value: Id[]): void;
+    onSearchInput(value: string): void;
+    hasSelection(): boolean;
+    validate(): {
+        isValid: boolean;
+        errorMessage: string | null;
+    };
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<TwinlistModelValue<Id>>;
+        default: null;
+    };
+    initialCaseSensitiveSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    initialSearchTerm: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Hiding and disabling
+     */
+    showSearch: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    disabled: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    showEmptyState: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * Labels
+     */
+    leftLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    rightLabel: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    withSearchLabel: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    searchLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    unknownValuesText: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Is only used when emptyStateComponent is null
+     */
+    emptyStateLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    /**
+     * this component is displayed centered in the middle of the box in case it is empty
+     */
+    emptyStateComponent: {
+        default: null;
+        type: ObjectConstructor;
+    };
+    /**
+     * Controls the size of the list.
+     * Number of visible items (for others user need to scroll)
+     * - 0 means all
+     * - values 1 - 4  are ignored; 5 is minimum
+     */
+    size: {
+        type: NumberConstructor;
+        default: number;
+        validator(value: number): boolean;
+    };
+    isValid: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    /**
+     * List of possible values. Each item must have an `id` and a `text` property
+     * @example
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF'
+     * }, {
+     *   id: 'XLS',
+     *   text: 'Excel',
+     * }]
+     */
+    possibleValues: {
+        type: PropType<PossibleValue[]>;
+        default: () => never[];
+    };
+    /**
+     * If this setting is true, on a change of possible values, the currently
+     * chosen values which are missing with respect to the new possible values
+     * are removed.
+     */
+    filterChosenValuesOnPossibleValuesChange: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: false;
+    };
+    compact: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    size: number;
+    disabled: boolean;
+    compact: boolean;
+    possibleValues: PossibleValue[];
+    modelValue: TwinlistModelValue<Id>;
+    isValid: boolean;
+    emptyStateLabel: string;
+    emptyStateComponent: Record<string, any>;
+    showEmptyState: boolean;
+    initialCaseSensitiveSearch: boolean;
+    initialSearchTerm: string;
+    showSearch: boolean;
+    leftLabel: string;
+    rightLabel: string;
+    withSearchLabel: boolean;
+    searchLabel: string;
+    searchPlaceholder: string;
+    unknownValuesText: string;
+    filterChosenValuesOnPossibleValuesChange: boolean;
+}, {}>;
+export default _default;