@knime/scripting-editor 0.0.106 → 0.0.108

package/dist/node_modules/@knime/ui-extension-renderer/src/api/services/alert.d.ts

@@ -0,0 +1,48 @@
+export declare const USER_ERROR_CODE = -32001;
+export declare const INTERNAL_ERROR_CODE = -32000;
+export declare const USER_ERROR_CODE_BLOCKING = -32002;
+export type UserErrorCode = typeof USER_ERROR_CODE | typeof USER_ERROR_CODE_BLOCKING;
+export type AlertType = "error" | "warn";
+export type WarningData = {
+    message: string;
+    details?: string;
+};
+export type WarningAlert = {
+    type: "warn";
+    warnings: WarningData[];
+};
+export type UserErrorAlert = {
+    type: "error";
+    code: UserErrorCode;
+    message: string;
+    data: {
+        details?: string | null;
+    };
+};
+export type InternalErrorAlert = {
+    type: "error";
+    code: typeof INTERNAL_ERROR_CODE;
+    message: string;
+    data: {
+        stackTrace: string[];
+        typeName: string;
+    };
+};
+export type OtherErrorAlert = {
+    type: "error";
+    /**
+     * This code is just an internal tool to identify the error type. If there exists a
+     * specific code for the error, it is instead stored in the `originalCode` field.
+     */
+    code?: null;
+    /**
+     * We include this as a separate field since if we would use it as the `code` field,
+     * it would no longer be possible to distinguish between a generic error and a
+     * user/internal error for typescript by checking the `code` field.
+     */
+    originalCode?: Exclude<number, typeof INTERNAL_ERROR_CODE | UserErrorCode>;
+    message: string;
+    data?: null;
+};
+export type ErrorAlert = UserErrorAlert | InternalErrorAlert | OtherErrorAlert;
+export type Alert = ErrorAlert | WarningAlert;

package/dist/node_modules/@knime/ui-extension-renderer/src/api/services/index.d.ts

@@ -0,0 +1,6 @@
+export * from './alert';
+export * from './DataServiceType';
+export * from './ExtensionTypes';
+export * from './RenderingConfig';
+export * from './ColorModel';
+export * from './selection';

package/dist/node_modules/@knime/ui-extension-renderer/src/api/services/selection.d.ts

@@ -0,0 +1,22 @@
+import { Identifiers } from '../uiExtensionService';
+/**
+ * Selection service modes available by default to UI Extension nodes.
+ */
+export type SelectionMode = "REPLACE" | "ADD" | "REMOVE";
+/**
+ * Used both for the communication to and from the ui extension.
+ */
+export type SelectionParams = Identifiers & {
+    mode: SelectionMode;
+    selection: string[];
+    error?: null;
+};
+export type ErroneousSelectionEventPayload = Identifiers & {
+    mode: SelectionMode;
+    selection: null;
+    /**
+     * Message of the error during a selection translation
+     */
+    error: string;
+};
+export type SelectionEventPayload = SelectionParams | ErroneousSelectionEventPayload;

package/dist/node_modules/@knime/ui-extension-renderer/src/api/uiExtensionService.d.ts

@@ -0,0 +1,169 @@
+import { AddPushEventListener } from './pushEvents';
+import { ColorModel } from './services/ColorModel';
+import { DataServiceType } from './services/DataServiceType';
+import { ExtensionType } from './services/ExtensionTypes';
+import { RenderingConfig } from './services/RenderingConfig';
+import { Alert } from './services/alert';
+import { SelectionParams } from './services/selection';
+export type Identifiers = {
+    /**
+     * the id of the node in the workflow.
+     */
+    projectId: string;
+    /**
+     * the project id of the workflow.
+     */
+    workflowId: string;
+    /**
+     * the workflow id.
+     */
+    nodeId: string;
+};
+/**
+ * The configuration of the client-side UIExtension implementation
+ */
+export type UIExtensionServiceConfig = Identifiers & {
+    /**
+     * the type of the extension (effects the api behavior).
+     */
+    extensionType: ExtensionType;
+    /**
+     * optional initial data to provide directly to the UI Extension.
+     */
+    initialData?: {
+        result?: string | object;
+        userError?: object;
+        internalError?: object;
+    };
+    /**
+     * optional initial selection to provide directly to the UI Extension.
+     */
+    initialSelection?: object;
+    /**
+     * optional initial state supplying the UI Extension with the shared state of
+     * already existing other UI Extensions.
+     */
+    initialSharedData?: object;
+    /**
+     * rendering config to determine in which context the ui extension is rendered
+     */
+    renderingConfig?: RenderingConfig;
+    hasNodeView: boolean;
+    writeProtected?: boolean;
+    /**
+     * optional color model per column used to map data cell values
+     * (numeric xor nominal) of a column to hexadecimal color codes
+     */
+    colorModels?: Record<string, ColorModel>;
+    /**
+     * optional color model used to map column names to hexadecimal color
+     * codes
+     */
+    columnNamesColorModel?: ColorModel;
+    /**
+     * whether the ui-extension (dialog) should initially be opened in large mode
+     */
+    startEnlarged?: boolean;
+};
+export type ApplyState = 
+/**
+ * Settings are clean, so they do not need to be applied.
+ */
+"clean"
+/**
+ *Settings are dirty, i.e. can be applied, but if the node is currently executed,
+ *applying the settings does not reset the node.
+ */
+ | "executed"
+/**
+ * Settings are dirty, i.e. can be applied. If they are applied the node will have to be
+ * reset and requires re-execution
+ */
+ | "configured"
+/**
+ * The settings are dirty and invalid, leaving the node in an idle state when applied.
+ * We sometimes do want to allow applying such settings when they could become valid
+ * at a later point without changing the dialog (e.g. when the value of a flow variable
+ *  changes)
+ */
+ | "idle";
+export type ViewState = 
+/**
+ * Settings are clean.
+ */
+"clean"
+/**
+ * The settings are dirty but previewing these settings in the view is still possible without a re-execution.
+ */
+ | "executed"
+/**
+ * The settings are dirty and require re-execution to show the resulting view.
+ */
+ | "configured"
+/**
+ * The settings are dirty and invalid, i.e. it is not even possible to execute the node with these settings.
+ */
+ | "idle";
+export type APILayerDirtyState = {
+    apply: ApplyState;
+    view: ViewState;
+};
+export interface DataValueViewConfig {
+    rowIndex: number;
+    colIndex: number;
+    anchor: {
+        x: number;
+        y: number;
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+        width: number;
+        height: number;
+    };
+}
+type SomeKnimeUiApiResponse = {
+    isSome: true;
+    result: unknown;
+};
+type NoneKnimeUiApiResponse = {
+    isSome: false;
+};
+type KnimeUiApiResponse = SomeKnimeUiApiResponse | NoneKnimeUiApiResponse;
+/**
+ * API layer definition for the UIExtension service. This contract
+ * represents the method implementations that the embedder of Extensions
+ * needs to supply in order to make the communication with Extensions work properly
+ */
+export type UIExtensionServiceAPILayer = {
+    getResourceLocation: (path: string) => Promise<string>;
+    callNodeDataService: (params: Identifiers & {
+        extensionType: string;
+        serviceType: DataServiceType;
+        dataServiceRequest: string;
+    }) => Promise<unknown>;
+    callKnimeUiApi?: (method: string, params: object | readonly unknown[] | undefined) => Promise<KnimeUiApiResponse>;
+    updateDataPointSelection: (params: SelectionParams) => Promise<unknown>;
+    setReportingContent: (content: string | false) => void;
+    imageGenerated: (image: string) => void;
+    /**
+     * TODO UIEXT-1791 Rename
+     */
+    publishData: (data: unknown) => void;
+    onDirtyStateChange: (newDirtyState: APILayerDirtyState) => void;
+    setControlsVisibility: (param: {
+        shouldBeVisible: boolean;
+    }) => void;
+    onApplied: (payload: {
+        /**
+         * Whether applying has been successful
+         */
+        isApplied: boolean;
+    }) => void;
+    sendAlert: (alert: Alert) => void;
+    getConfig: () => UIExtensionServiceConfig;
+    showDataValueView: (config: DataValueViewConfig) => void;
+    closeDataValueView: () => void;
+};
+export type UIExtensionService<APILayer = UIExtensionServiceAPILayer> = APILayer & AddPushEventListener;
+export {};

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/embedder.d.ts

@@ -0,0 +1,14 @@
+import { DispatchPushEvent, UIExtensionService, UIExtensionServiceAPILayer } from '../api';
+export declare const addDefaults: (apiLayer: UIExtensionServiceAPILayer) => UIExtensionServiceAPILayer;
+/**
+ * exported for test purposes
+ */
+export declare const setUpCustomEmbedderService: <APILayer>(apiLayer: APILayer) => DispatchPushEvent & {
+    service: UIExtensionService<APILayer>;
+};
+/**
+ * Service used to communicate with KNIME's internal extensions which are not inside an iframe.
+ */
+export declare const setUpEmbedderService: (apiLayer: UIExtensionServiceAPILayer) => DispatchPushEvent & {
+    service: UIExtensionService;
+};

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/iframe/embedder.d.ts

@@ -0,0 +1,34 @@
+import { UIExtensionServiceAPILayer } from '../../api';
+export declare const setUpIframeEmbedderService: (apiLayer: UIExtensionServiceAPILayer, iframeContentWindow: Window) => Promise<{
+    dispatchPushEvent: <T extends import('../../api').EventType>(event: (T extends keyof {
+        SelectionEvent: import('../../api').SelectionEventPayload;
+        DisplayModeEvent: import('../../api').DisplayModeEventPayload;
+        DataEvent: unknown;
+        ApplyDataEvent: undefined;
+        DataValueViewShownEvent: boolean;
+    } ? {
+        SelectionEvent: import('../../api').SelectionEventPayload;
+        DisplayModeEvent: import('../../api').DisplayModeEventPayload;
+        DataEvent: unknown;
+        ApplyDataEvent: undefined;
+        DataValueViewShownEvent: boolean;
+    }[T] : unknown) extends undefined ? {
+        eventType: T;
+        payload?: undefined;
+    } : {
+        eventType: T;
+        payload: T extends keyof {
+            SelectionEvent: import('../../api').SelectionEventPayload;
+            DisplayModeEvent: import('../../api').DisplayModeEventPayload;
+            DataEvent: unknown;
+            ApplyDataEvent: undefined;
+            DataValueViewShownEvent: boolean;
+        } ? {
+            SelectionEvent: import('../../api').SelectionEventPayload;
+            DisplayModeEvent: import('../../api').DisplayModeEventPayload;
+            DataEvent: unknown;
+            ApplyDataEvent: undefined;
+            DataValueViewShownEvent: boolean;
+        }[T] : unknown;
+    }) => void;
+}>;

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/iframe/index.d.ts

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

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/iframe/pushEvents.d.ts

@@ -0,0 +1,11 @@
+import { DispatchPushEvent, EventType, PushEvent } from '../../api';
+/**
+ * This {@link DispatchPushEvent} implementation is used by
+ * the embedder side of an iframe ui extension to dispatch events
+ * to any listeners registered by an {@link IframeAddEventListener} inside that iframe
+ */
+export declare class IframeDispatchEvent implements DispatchPushEvent {
+    private readonly contentWindow;
+    constructor(contentWindow: Window);
+    dispatchPushEvent<T extends EventType>(event: PushEvent<T>): void;
+}

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/iframe/types/index.d.ts

@@ -0,0 +1,33 @@
+type MethodSignature<Name extends string = string, Params extends unknown[] = unknown[], Result = unknown> = {
+    name: Name;
+    params: Params;
+    result: Result;
+};
+export type Method = (...args: never[]) => unknown;
+export type API = Record<string, Method>;
+type Names<T extends API> = keyof T & string;
+type MethodSignatureForKey<T extends API, K extends Names<T>> = MethodSignature<K, Parameters<T[K]>, ReturnType<T[K]>>;
+export type ProxyMethod<T extends MethodSignature> = (method: T["name"], ...params: T["params"]) => T["result"];
+type ProxyMethodForKey<T extends API, K extends Names<T>> = ProxyMethod<MethodSignatureForKey<T, K>>;
+export type ProxyMethodFor<T extends API> = {
+    [K in Names<T>]: ProxyMethodForKey<T, K>;
+}[Names<T>];
+type Payload<T extends MethodSignature> = {
+    method: T["name"];
+    params: T["params"];
+};
+export type PayloadForKey<T extends API, K extends Names<T>> = Payload<MethodSignatureForKey<T, K>>;
+export type IframeProxyMessageEvent<T = string> = {
+    type: T;
+    requestId: string;
+};
+export type RequestForKey<A extends API, K extends Names<A>> = IframeProxyMessageEvent<"UIExtensionRequest"> & {
+    payload: PayloadForKey<A, K>;
+};
+export type RequestFor<A extends API> = {
+    [K in Names<A>]: RequestForKey<A, K>;
+}[Names<A>];
+export type Response<T = unknown> = IframeProxyMessageEvent<"UIExtensionResponse"> & {
+    payload: T;
+};
+export {};

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/iframe/utils/events.d.ts

@@ -0,0 +1,3 @@
+import { IframeMessageEvent, WrappedIframePushEvent } from './types';
+export declare const isWrappedEventOfType: (event: IframeMessageEvent, type: string) => type is "UIExtensionPushEvent";
+export declare const toWrappedEventOfType: <T, S>(payload: T, type: S) => WrappedIframePushEvent<T, S>;

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/iframe/utils/types.d.ts

@@ -0,0 +1,6 @@
+import { EventType, PushEvent } from '../../../api';
+export interface WrappedIframePushEvent<T, S> {
+    type: S;
+    payload: T;
+}
+export type IframeMessageEvent = MessageEvent<WrappedIframePushEvent<PushEvent<EventType>, "UIExtensionPushEvent">>;

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/index.d.ts

@@ -0,0 +1,2 @@
+export * from './iframe';
+export * from './embedder';

package/dist/node_modules/@knime/ui-extension-renderer/src/logic/pushEvents.d.ts

@@ -0,0 +1,10 @@
+import { AddPushEventListener, DispatchPushEvent, EventType, PushEvent, PushEventListenerCallback } from '../api';
+/**
+ * This handler is used for non-iframe push event communication.
+ * The embedder dispatches events triggering listeners registered by the client.
+ */
+export declare class DefaultEventHandler implements AddPushEventListener, DispatchPushEvent {
+    private readonly callbacksMap;
+    addPushEventListener<T extends EventType>(eventType: EventType, callback: PushEventListenerCallback<T>): () => void;
+    dispatchPushEvent<T extends EventType>(event: PushEvent<T>): void;
+}

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/index.d.ts

@@ -0,0 +1,5 @@
+import { default as UIExtension } from './UIExtension.vue';
+import { default as UIExtensionAlerts } from './UIExtensionAlerts.vue';
+import { default as UIExtensionBlockingErrorView } from './UIExtensionBlockingErrorView.vue';
+export { UIExtension, UIExtensionAlerts, UIExtensionBlockingErrorView };
+export type { ExtensionConfig, NodeInfo, ResourceInfo, ResourceTypes, UIExtensionAPILayer, } from './types';

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/types/ExtensionConfig.d.ts

@@ -0,0 +1,12 @@
+import { UIExtensionServiceConfig } from '../../api';
+import { NodeInfo } from './NodeInfo';
+import { ResourceInfo } from './ResourceInfo';
+/**
+ * The base configuration of any UI Extension which contains all of the relevant information about the UI Extension
+ * node it references. This information allows the framework to coordinate communication between the frontend
+ * application and the target node in the workflow.
+ */
+export type ExtensionConfig = UIExtensionServiceConfig & {
+    resourceInfo: ResourceInfo;
+    nodeInfo?: NodeInfo;
+};

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/types/NodeInfo.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @property {string} [nodeAnnotation] - the optional annotation associated with the node.
+ * @property {string} nodeState - the current state of the node.
+ * @property {string} [nodeErrorMessage] - the optional error message associated with a node in the failed state.
+ * @property {string} [nodeWarnMessage] - the optional warning message associated with a node in the failed state.
+ * @property {string} nodeName - the human-readable node name as it's registered with the node description.
+ */
+export type NodeInfo = {
+    nodeAnnotation?: string;
+    nodeState: string;
+    nodeErrorMessage?: string;
+    nodeWarnMessage?: string;
+    nodeName: string;
+};

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/types/ResourceInfo.d.ts

@@ -0,0 +1,13 @@
+import { ResourceTypes } from './ResourceTypes';
+/**
+ * @property {string} id - unique identifier based on the factory class of the node.
+ * @property {ResourceTypes} type - the resource type associated with the extension.
+ * @property {string} [path] - the optional relative path of the resource (for remote resources).
+ * @property {string} [url] - the optional absolute url of the resource (for local resources).
+ */
+export type ResourceInfo = {
+    id: string;
+    type: ResourceTypes;
+    path?: string;
+    url?: string;
+};

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/types/ResourceTypes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum for extension resource types.
+ * @readonly
+ * @enum {string}
+ */
+export type ResourceTypes = 
+/** Indicates the resource should be loaded as a complete HTML page. */
+"HTML"
+/** Indicates the resource is a shadow root based ui extension app and should
+ * be treated as a ES6 module that exports a mount function as default. */
+ | "SHADOW_APP";

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/types/UIExtensionAPILayer.d.ts

@@ -0,0 +1,11 @@
+import { EventType, PushEvent, UIExtensionServiceAPILayer } from '../../api';
+type UIExtensionAPILayer = Pick<UIExtensionServiceAPILayer, "callNodeDataService" | "imageGenerated" | "setReportingContent" | "publishData" | "updateDataPointSelection" | "getResourceLocation" | "onDirtyStateChange" | "onApplied" | "setControlsVisibility" | "sendAlert" | "showDataValueView" | "closeDataValueView"> & {
+    /**
+     * @returns the respective deregistration method
+     */
+    registerPushEventService: (service: {
+        dispatchPushEvent: <T extends EventType>(event: PushEvent<T>) => void;
+    }) => () => void;
+    callKnimeUiApi?: UIExtensionServiceAPILayer["callKnimeUiApi"];
+};
+export type { UIExtensionAPILayer };

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { ExtensionConfig } from './ExtensionConfig';
+export type { NodeInfo } from './NodeInfo';
+export type { ResourceInfo } from './ResourceInfo';
+export type { ResourceTypes } from './ResourceTypes';
+export type { UIExtensionAPILayer } from './UIExtensionAPILayer';
+export * from '../../api';

package/dist/node_modules/@knime/ui-extension-renderer/src/vueComponents/useDynamicImport.d.ts

@@ -0,0 +1,8 @@
+export declare const useDynamicImport: () => {
+    dynamicImport: (location: string, ignoreCache?: boolean) => Promise<{
+        default: (...args: unknown[]) => {
+            teardown: () => void;
+        };
+    }>;
+    clearCache: () => void;
+};

package/dist/node_modules/@knime/ui-extension-service/dist/index-BqVVMPc5.d.ts

@@ -0,0 +1,10 @@
+declare let x: {
+    new (e: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+declare var _: {};
+export { x as A, _ as c };

package/dist/node_modules/@knime/ui-extension-service/dist/index2.d.ts

@@ -0,0 +1,18 @@
+export { V as DataValueViewService };
+declare const V_base: {
+    new (e: any): {
+        baseService: any;
+    };
+    getInstance(): Promise<{
+        baseService: any;
+    }>;
+};
+declare class V extends V_base {
+    showDataValueView(e: any): void;
+    closeDataValueView(): void;
+    /**
+     * This needs to be called in order to enable listening to push events of the
+     * embedder informing the extension whether the data value views are open or closed.
+     */
+    setDataValueViewStateListener(e: any): void;
+}