@knime/scripting-editor 0.0.111 → 0.0.112

package/dist/scripting-service-browser-mock.js

@@ -31,9 +31,12 @@ const l = 100, a = 2e3, g = (r, ...n) => {
       Returning undefined.`
       ), Promise.resolve());
     },
+    getOutputPreviewTableInitialData() {
+      return Promise.resolve(void 0);
+    },
     // Settings and dialog window
     isCallKnimeUiApiAvailable() {
-      return i("Called scriptingService.isCallKnimeUiApiAvailable"), Promise.resolve(!0);
+      return i("Called scriptingService.isCallKnimeUiApiAvailable"), Promise.resolve(!1);
     },
     isKaiEnabled() {
       return i("Called scriptingService.isKaiEnabled"), Promise.resolve(!0);

package/dist/settings-service-browser-mock.js

@@ -13,7 +13,7 @@ const r = {
       `Called settings service mock registerSettings callback unsetValue ${t}`
     );
   }
-}), l = () => (e("Called settings service mock registerSettings"), Promise.resolve(() => (e("Called settings service mock registerSettings callback"), {
+}), l = () => (e("Called settings service mock registerSettings"), () => (e("Called settings service mock registerSettings callback"), {
   setValue: () => {
     e("Called settings service mock registerSettings callback setValue");
   },
@@ -23,9 +23,11 @@ const r = {
   addControllingFlowVariable: () => (e(
     "Called settings service mock registerSettings callback addControllingFlowVariable"
   ), s("addControllingFlowVariable"))
-}))), a = (t) => ({
-  getSettings: () => (e("Called settings service mock getSettings"), Promise.resolve(t ?? r)),
-  registerSettingsGetterForApply: () => (e("Called settings service mock registerSettingsGetterForApply"), Promise.resolve()),
+})), a = (t) => ({
+  getSettings: () => (e("Called settings service mock getSettings"), t ?? r),
+  registerSettingsGetterForApply: () => {
+    e("Called settings service mock registerSettingsGetterForApply");
+  },
   registerSettings: l
 });
 export {

package/dist/src/components/LoadingApp.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/src/init.d.ts

@@ -0,0 +1,28 @@
+import { GenericInitialData } from './initial-data-service';
+import { ScriptingServiceType } from './scripting-service';
+import { SettingsServiceType } from './settings-service';
+export declare const getScriptingService: () => ScriptingServiceType;
+export declare const getInitialData: () => GenericInitialData;
+export declare const getSettingsService: () => SettingsServiceType;
+/**
+ * Initializes the scripting editor services and sets up the display mode.
+ *
+ * This function must be called before using any other scripting editor functionality.
+ * It creates and configures the singleton instances of ScriptingService and SettingsService,
+ * fetches initial data from the backend, and sets up display mode management.
+ *
+ * @returns A Promise that resolves when all services are initialized
+ */
+export declare const init: () => Promise<void>;
+export type InitMockData = {
+    scriptingService?: ScriptingServiceType;
+    initialData?: GenericInitialData;
+    settingsService?: SettingsServiceType;
+    displayMode?: "small" | "large";
+};
+export declare const initMocked: (mockData: InitMockData) => void;
+/**
+ * Initialize the console event handler to forward console events from the
+ * backend to the frontend console handler.
+ */
+export declare const initConsoleEventHandler: () => void;

package/dist/src/initial-data-service-browser-mock.d.ts

@@ -1,8 +1,7 @@
 import { InputOutputModel } from './components/InputOutputItem.vue';
-import { GenericInitialData, InitialDataServiceType, InputConnectionInfo } from './initial-data-service';
+import { GenericInitialData, InputConnectionInfo } from './initial-data-service';
 export declare const DEFAULT_INPUT_OBJECTS: InputOutputModel[];
 export declare const DEFAULT_PORT_INFORMATION: InputConnectionInfo[];
 export declare const DEFAULT_OUTPUT_OBJECTS: InputOutputModel[];
 export declare const DEFAULT_FLOW_VARIABLE_INPUTS: InputOutputModel;
 export declare const DEFAULT_INITIAL_DATA: GenericInitialData;
-export declare const createInitialDataServiceMock: (data?: GenericInitialData) => InitialDataServiceType;

package/dist/src/initial-data-service.d.ts

@@ -4,10 +4,8 @@ export type PortViewConfig = {
     portViewIdx: number;
 };
 export type PortConfig = {
-    /**
-     * null if no node is connected to an input port
-     */
-    nodeId: string | null;
+    /** undefined if no node is connected to an input port */
+    nodeId?: string;
     portIdx: number;
     portViewConfigs: PortViewConfig[];
     portName: string;
@@ -39,10 +37,5 @@ export type GenericInitialData = {
     inputConnectionInfo: InputConnectionInfo[];
     outputObjects?: InputOutputModel[];
     kAiConfig: KAIConfig;
+    [key: string]: unknown;
 };
-declare const initialDataService: {
-    getInitialData: () => Promise<GenericInitialData>;
-};
-export type InitialDataServiceType = typeof initialDataService;
-export declare const getInitialDataService: () => InitialDataServiceType;
-export {};

package/dist/src/lsp/knime-io.d.ts

@@ -7,7 +7,7 @@ import { AbstractMessageReader, AbstractMessageWriter, DataCallback, Disposable,
 export declare class KnimeMessageReader extends AbstractMessageReader implements MessageReader {
     protected messageCache: string[];
     protected callback: DataCallback | null;
-    constructor();
+    constructor(registerEventHandler: (eventHandler: (message: string) => void) => void);
     listen(callback: DataCallback): Disposable;
     readMessage(message: string): void;
 }
@@ -15,6 +15,8 @@ export declare class KnimeMessageReader extends AbstractMessageReader implements
  * This class is used to write messages to the language server.
  */
 export declare class KnimeMessageWriter extends AbstractMessageWriter implements MessageWriter {
+    private readonly sendMessage;
+    constructor(sendMessage: (message: string) => Promise<void>);
     write(msg: Message): Promise<void>;
     end(): void;
 }

package/dist/src/scripting-service.d.ts

@@ -1,11 +1,29 @@
+import { JsonDataService } from '@knime/ui-extension-service';
 import { PortConfig } from './initial-data-service';
 import { MonacoLSPConnection } from './lsp/connection';
+import { PublicAPI } from './types/public-api';
 export type UsageData = {
     limit: number | null;
     used: number;
 };
-declare const scriptingService: {
+export declare class ScriptingService {
+    private readonly jsonDataService;
+    private readonly eventPoller;
+    /**
+     * Internal constructor — use `getScriptingService()` from `init.ts` instead.
+     *
+     * Client applications will call `init()` first, then use the getter to access
+     * the service. Within this repository, developers can assume `init()` has been
+     * called and the scripting service is available via `getScriptingService()`.
+     *
+     * This constructor should only be called from the `init()` function and in unit tests.
+     *
+     * @internal
+     * @param jsonDataService The JSON data service used for communication with the backend.
+     */
+    constructor(jsonDataService: JsonDataService);
     sendToService(methodName: string, options?: any[] | undefined): Promise<any>;
+    getOutputPreviewTableInitialData(): Promise<string | undefined>;
     registerEventHandler(type: string, handler: (args: any) => void): void;
     connectToLanguageServer(): Promise<MonacoLSPConnection>;
     isCallKnimeUiApiAvailable(portToTestFor: PortConfig): Promise<boolean>;
@@ -13,33 +31,6 @@ declare const scriptingService: {
     isLoggedIntoHub(): Promise<boolean>;
     getAiDisclaimer(): Promise<string>;
     getAiUsage(): Promise<UsageData | null>;
-};
-export type ScriptingServiceType = typeof scriptingService;
-/**
- * Get the singleton instance of the scripting service. The scripting service
- * provides access to the backend KNIME instance.
- *
- * Note that it is possible to provide a custom scripting service instance in
- * a browser development environment (see example).
- *
- * @returns the scripting service instance
- * @example
- * import { createScriptingServiceMock } from "@knime/scripting-editor/scripting-service-browser-mock";
- * import { getScriptingService } from "@knime/scripting-editor";
- *
- * if (import.meta.env.MODE === "development.browser") {
- *   const scriptingService = createScriptingServiceMock({
- *     sendToServiceMockResponses: {
- *       myBackendFunction: (options) => {
- *         consola.log("called my backend function with", options);
- *         return Promise.resolve();
- *       },
- *     },
- *   });
- *
- *   Object.assign(getScriptingService(), scriptingService);
- * }
- */
-export declare const getScriptingService: () => ScriptingServiceType;
-export declare const initConsoleEventHandler: () => void;
-export {};
+}
+/** Type representing the public API of ScriptingService */
+export type ScriptingServiceType = PublicAPI<ScriptingService>;

package/dist/src/settings-service-browser-mock.d.ts

@@ -1,5 +1,5 @@
 import { SettingState } from '@knime/ui-extension-service';
 import { GenericNodeSettings, SettingsServiceType } from './settings-service';
 export declare const DEFAULT_INITIAL_SETTINGS: GenericNodeSettings;
-export declare const registerSettingsMock: () => Promise<() => SettingState<unknown>>;
+export declare const registerSettingsMock: () => () => SettingState<unknown>;
 export declare const createSettingsServiceMock: (data?: GenericNodeSettings) => SettingsServiceType;

package/dist/src/settings-service.d.ts

@@ -1,12 +1,28 @@
+import { DialogService, JsonDataService } from '@knime/ui-extension-service';
+import { PublicAPI } from './types/public-api';
 export type GenericNodeSettings = {
     [key: string]: any;
     settingsAreOverriddenByFlowVariable?: boolean;
 };
-declare const settingsService: {
-    getSettings: () => Promise<GenericNodeSettings>;
-    registerSettingsGetterForApply: (settingsGetter: () => GenericNodeSettings) => Promise<void>;
-    registerSettings: (modelOrView: "model" | "view") => Promise<(initialSetting: unknown) => import('@knime/ui-extension-service').SettingState<unknown>>;
-};
-export type SettingsServiceType = typeof settingsService;
-export declare const getSettingsService: () => SettingsServiceType;
-export {};
+export declare class SettingsService {
+    private readonly initialSettings;
+    private readonly dialogService;
+    private readonly jsonDataService;
+    /**
+     * Internal constructor — do not call directly.
+     *
+     * This constructor is intended for internal use only.
+     * Please use the `init` method in `init.ts` to create the singleton instance and
+     * access via `getScriptingService()`. Only one instance should be created via the
+     * designated initialization method.
+     *
+     * @internal
+     * @param jsonDataService The service used for JSON data operations.
+     */
+    constructor(initialSettings: GenericNodeSettings, dialogService: DialogService, jsonDataService: JsonDataService);
+    getSettings(): GenericNodeSettings;
+    registerSettingsGetterForApply(settingsGetter: () => GenericNodeSettings): void;
+    registerSettings(modelOrView: "model" | "view"): <T>(initialSetting: T) => import('@knime/ui-extension-service').SettingState<T>;
+}
+/** Type representing the public API of SettingsService */
+export type SettingsServiceType = PublicAPI<SettingsService>;

package/dist/src/types/public-api.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utility type that extracts the public API from a class.
+ * Automatically excludes private members and constructor.
+ * Only includes callable methods (functions).
+ *
+ * @template T The class type to extract the public API from
+ */
+export type PublicAPI<T> = Pick<T, {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@knime/scripting-editor",
   "type": "module",
-  "version": "0.0.111",
+  "version": "0.0.112",
   "description": "Shared Scripting Editor components for KNIME",
   "author": "KNIME AG, Zurich, Switzerland",
   "license": "See the file license.txt",
@@ -86,6 +86,7 @@
   "module": "./dist/main.js",
   "exports": {
     ".": "./dist/main.js",
+    "./loading": "./dist/loading.js",
     "./scripting-service-browser-mock": "./dist/scripting-service-browser-mock.js",
     "./settings-service-browser-mock": "./dist/settings-service-browser-mock.js",
     "./initial-data-service-browser-mock": "./dist/initial-data-service-browser-mock.js"

package/dist/src/settings-helper.d.ts

@@ -1,21 +0,0 @@
-import { SettingState } from '@knime/ui-extension-service';
-import { GenericInitialData } from './initial-data-service';
-import { GenericNodeSettings } from './settings-service';
-type InitialDataAndSettings = {
-    initialData: GenericInitialData;
-    settings: GenericNodeSettings;
-};
-declare class SettingsHelper {
-    private static instance;
-    private jsonDataService;
-    private readonly dialogService;
-    private cachedInitialDataAndSettings;
-    private constructor();
-    private loadDataIntoCache;
-    getInitialDataAndSettings(): Promise<InitialDataAndSettings>;
-    registerApplyListener(settingsGetter: () => GenericNodeSettings): Promise<void>;
-    registerSettings<T>(modelOrView: "view" | "model"): Promise<(initialSetting: T) => SettingState<T>>;
-    static getInstance(): SettingsHelper;
-}
-export declare const getSettingsHelper: () => SettingsHelper;
-export {};