@kvaser/canking-api 7.1.0-beta.231

package/README.md

@@ -0,0 +1,87 @@
+# Kvaser CanKing GUI Extensions SDK
+
+## Prerequisites
+
+Before creating a new CanKing GUI Extension project there are some softwares that need to be installed.
+
+### Must have
+
+- Node.js: <https://nodejs.org/>
+- Kvaser CanKing: <https://kvaser.com/canking/>
+- Kvaser Drivers: <https://resources.kvaser.com/7330130980013/latest/kvaser_drivers_setup.exe>
+
+### Preferred
+
+- nvm: <https://github.com/coreybutler/nvm-windows/releases>
+  - download latest version from assets
+  - install and do ```nvm list``` to display node.js versions
+  - install node.js version 22.9: ```nvm install 22.9```
+  - change node.js version to 22.9: ```nvm use 22.9```
+  - **NOTE:**
+    - If nvm keyword can't be found make sure environment path for nvm.exe is set.
+    - CanKing is coded with node version 22.9, so version 22.9 is recommended.
+
+## Generate a new CanKing GUI Extension project
+
+To create a new CanKing GUI Extension project the @kvaser/canking-api package is needed. The @kvaser/canking-api
+package is published to <http://artifact.kvaser.se/artifactory/api/npm/libs-npm>.  
+
+The @kvaser/canking-api package includes a script that can be used for creating a new CanKing GUI Extension package.
+The script is used like this:
+
+    npx @kvaser/canking-api <project-name> [options]
+
+    Arguments:
+      project-name          The project name. A new project folder with this name will be created in the current folder.
+
+    Options:
+      -V, --version         output the version number
+      --view-name <string>  workspace view name (default: "")
+      --desc <string>       project description (default: "A CanKing GUI extension.")
+      --author <string>     project author (default: "")
+      --verbose             print additional logs
+      --force               use installed script even if a newer version exists
+      --show-doc            opens the documentation
+      -h, --help            display help for command
+
+To create a new CanKing workspace view extension run these commands:
+
+    npm config set '@kvaser:registry' http://artifact.kvaser.se/artifactory/api/npm/libs-npm
+    npx @kvaser/canking-api <project-name> --view-name <view-name> --desc <description> --author <author>
+
+The first command will point out the correct registry to be used for @kvaser packages and the second command will run the
+script to create the project.
+
+## Develop a CanKing GUI Extension
+
+To match the CanKing look and feel, it's recommended to use Material UI components when applicable,
+<https://mui.com/material-ui/all-components/>.
+
+The WorkspaceView React component (src/WorkspaceVew/index.tsx) will be displayed when the extension is loaded into CanKing,
+so this is the component that should be implemented to implement the extension.
+
+To run the extension from command line enter:
+
+    npm run start
+
+To run the extension using VS Code debugger:
+
+- Select 'Run and Debug' or press Ctrl+Shift+D
+- Select the configuration named 'Debug'
+- Click on 'Start Debugging' or press F5
+
+To run a production build of the extension you can enter this command:
+
+    npm run startpreview
+
+## Package and Install a CanKing GUI Extension
+
+To package your extension for distribution you should run this command from the command line:
+
+    npm pack
+
+This command will create a tarball file in the root folder of your project called:
+
+    <project-name>-<version>.tgz
+
+This tarball can then be installed in CanKing using the head menu 'More'->'Extensions'->'Install'.

package/REDISTRIBUTABLES.txt

@@ -0,0 +1,5 @@
+Redistributable files in Kvaser CanKing GUI Extensions SDK
+===================================================================================================
+
+All files in the dist folder and in its sub-folders may be redistributed with your application,
+provided they are only used together with genuine Kvaser hardware.

package/dist/ElectronAPIFake.js

@@ -0,0 +1 @@
+"use strict";var p=Object.defineProperty;var g=(r,e,s)=>e in r?p(r,e,{enumerable:!0,configurable:!0,writable:!0,value:s}):r[e]=s;var t=(r,e,s)=>g(r,typeof e!="symbol"?e+"":e,s);require("long");const v=require("./measurement_settings.js");class d{constructor(e){t(this,"userSettings");this.userSettings=e}on(e,s){return()=>{}}once(e,s){return()=>{}}removeAllListeners(e){}removeListener(e,s){return this}send(e,...s){}invoke(e,...s){switch(e){case"rpc-get-devices":const n=[];return Promise.resolve(n);case"app-get-session-data":return Promise.resolve(null);case"app-get-user-settings":return Promise.resolve(this.userSettings);case"rpc-get-online-status":const o={isOnline:!1};return Promise.resolve(o);case"rpc-get-node-statuses":const c=[];return Promise.resolve(c);case"prj-get-meas-setup":return Promise.resolve(v.MeasurementSetup.create());case"prj-get-workspaces":const i=[];return Promise.resolve(i);case"prj-get-workspace-panes":const l=[];return Promise.resolve(l);case"app-get-workspace-view-session-data":case"rpc-start-periodic-transmission":return Promise.resolve("");case"rpc-get-message-log-file-formats":const u=[];return Promise.resolve(u);case"rpc-get-frame-definitions":const m=[];return Promise.resolve(m);case"mm-get-measurement-data-buffer":case"mm-get-latest-measurement-data":return Promise.resolve(frames);default:return Promise.resolve()}}postMessage(e,s,n){}sendSync(e,...s){}sendTo(e,s,...n){}sendToHost(e,...s){}}class P{insertCSS(e){return""}setZoomFactor(e){}setZoomLevel(e){}}class F{constructor(){t(this,"platform");t(this,"versions");t(this,"env")}}const a=r=>{const e={version:"1.0.0",theme:"light",language:"en",strings:{},showToolsPanel:!0,useHexNumericBase:!0,maxDataBytes:16,defaultProjectFolder:"",currentProjectFile:"",currentProjectFileName:"",recentProjectFiles:[],closeAppServiceAction:"prompt"};return{ipcRenderer:new d(r??e),webFrame:new P,process:new F}},f=a();exports.createElectronApiFake=a;exports.electronApiFake=f;

package/dist/ElectronAPIFake.mjs

@@ -0,0 +1,266 @@
+var u = Object.defineProperty;
+var p = (r, e, s) => e in r ? u(r, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : r[e] = s;
+var t = (r, e, s) => p(r, typeof e != "symbol" ? e + "" : e, s);
+import "long";
+import { ab as g } from "./measurement_settings.mjs";
+class v {
+  /**
+   * Creates a new IpcRendererFake.
+   */
+  constructor(e) {
+    t(this, "userSettings");
+    this.userSettings = e;
+  }
+  /**
+   * Listens to `channel`, when a new message arrives `listener` would be called with
+   * `listener(event, args...)`.
+   */
+  on(e, s) {
+    return () => {
+    };
+  }
+  /**
+   * Adds a one time `listener` function for the event. This `listener` is invoked
+   * only the next time a message is sent to `channel`, after which it is removed.
+   */
+  once(e, s) {
+    return () => {
+    };
+  }
+  /**
+   * Removes all listeners, or those of the specified `channel`.
+   */
+  removeAllListeners(e) {
+  }
+  /**
+   * Removes the specified `listener` from the listener array for the specified
+   * `channel`.
+   *
+   * @deprecated Use `on` listen return instead
+   *
+   */
+  removeListener(e, s) {
+    return this;
+  }
+  /**
+   * Send an asynchronous message to the main process via `channel`, along with
+   * arguments. Arguments will be serialized with the Structured Clone Algorithm,
+   * just like `window.postMessage`, so prototype chains will not be included.
+   * Sending Functions, Promises, Symbols, WeakMaps, or WeakSets will throw an
+   * exception.
+   *
+   * **NOTE:** Sending non-standard JavaScript types such as DOM objects or special
+   * Electron objects will throw an exception.
+   *
+   * Since the main process does not have support for DOM objects such as
+   * `ImageBitmap`, `File`, `DOMMatrix` and so on, such objects cannot be sent over
+   * Electron's IPC to the main process, as the main process would have no way to
+   * decode them. Attempting to send such objects over IPC will result in an error.
+   *
+   * The main process handles it by listening for `channel` with the `ipcMain`
+   * module.
+   *
+   * If you need to transfer a `MessagePort` to the main process, use
+   * `ipcRenderer.postMessage`.
+   *
+   * If you want to receive a single response from the main process, like the result
+   * of a method call, consider using `ipcRenderer.invoke`.
+   */
+  send(e, ...s) {
+  }
+  /**
+   * Resolves with the response from the main process.
+   *
+   * Send a message to the main process via `channel` and expect a result
+   * asynchronously. Arguments will be serialized with the Structured Clone
+   * Algorithm, just like `window.postMessage`, so prototype chains will not be
+   * included. Sending Functions, Promises, Symbols, WeakMaps, or WeakSets will throw
+   * an exception.
+   *
+   * **NOTE:** Sending non-standard JavaScript types such as DOM objects or special
+   * Electron objects will throw an exception.
+   *
+   * Since the main process does not have support for DOM objects such as
+   * `ImageBitmap`, `File`, `DOMMatrix` and so on, such objects cannot be sent over
+   * Electron's IPC to the main process, as the main process would have no way to
+   * decode them. Attempting to send such objects over IPC will result in an error.
+   *
+   * The main process should listen for `channel` with `ipcMain.handle()`.
+   *
+   * For example:
+   *
+   * If you need to transfer a `MessagePort` to the main process, use
+   * `ipcRenderer.postMessage`.
+   *
+   * If you do not need a response to the message, consider using `ipcRenderer.send`.
+   */
+  invoke(e, ...s) {
+    switch (e) {
+      case "rpc-get-devices":
+        const n = [];
+        return Promise.resolve(n);
+      case "app-get-session-data":
+        return Promise.resolve(null);
+      case "app-get-user-settings":
+        return Promise.resolve(this.userSettings);
+      case "rpc-get-online-status":
+        const a = { isOnline: !1 };
+        return Promise.resolve(a);
+      case "rpc-get-node-statuses":
+        const o = [];
+        return Promise.resolve(o);
+      case "prj-get-meas-setup":
+        return Promise.resolve(g.create());
+      case "prj-get-workspaces":
+        const c = [];
+        return Promise.resolve(c);
+      case "prj-get-workspace-panes":
+        const i = [];
+        return Promise.resolve(i);
+      case "app-get-workspace-view-session-data":
+      case "rpc-start-periodic-transmission":
+        return Promise.resolve("");
+      case "rpc-get-message-log-file-formats":
+        const l = [];
+        return Promise.resolve(l);
+      case "rpc-get-frame-definitions":
+        const m = [];
+        return Promise.resolve(m);
+      case "mm-get-measurement-data-buffer":
+      case "mm-get-latest-measurement-data":
+        return Promise.resolve(frames);
+      default:
+        return Promise.resolve();
+    }
+  }
+  /**
+   * Send a message to the main process, optionally transferring ownership of zero or
+   * more `MessagePort` objects.
+   *
+   * The transferred `MessagePort` objects will be available in the main process as
+   * `MessagePortMain` objects by accessing the `ports` property of the emitted
+   * event.
+   *
+   * **NOTE:** Cannot transfer these when `contextIsolation: true`.
+   *
+   * For example:
+   *
+   * For more information on using `MessagePort` and `MessageChannel`, see the MDN
+   * documentation.
+   */
+  postMessage(e, s, n) {
+  }
+  /**
+   * The value sent back by the `ipcMain` handler.
+   *
+   * Send a message to the main process via `channel` and expect a result
+   * synchronously. Arguments will be serialized with the Structured Clone Algorithm,
+   * just like `window.postMessage`, so prototype chains will not be included.
+   * Sending Functions, Promises, Symbols, WeakMaps, or WeakSets will throw an
+   * exception.
+   *
+   * **NOTE:** Sending non-standard JavaScript types such as DOM objects or special
+   * Electron objects will throw an exception.
+   *
+   * Since the main process does not have support for DOM objects such as
+   * `ImageBitmap`, `File`, `DOMMatrix` and so on, such objects cannot be sent over
+   * Electron's IPC to the main process, as the main process would have no way to
+   * decode them. Attempting to send such objects over IPC will result in an error.
+   *
+   * The main process handles it by listening for `channel` with `ipcMain` module,
+   * and replies by setting `event.returnValue`.
+   *
+   * warning: **WARNING**: Sending a synchronous message will block the whole
+   * renderer process until the reply is received, so use this method only as a last
+   * resort. It's much better to use the asynchronous version, `invoke()`.
+   */
+  sendSync(e, ...s) {
+  }
+  /**
+   * Sends a message to a window with `webContentsId` via `channel`.
+   *
+   * @deprecated This methond has been removed since Electron 28.
+   */
+  sendTo(e, s, ...n) {
+  }
+  /**
+   * Like `ipcRenderer.send` but the event will be sent to the `<webview>` element in
+   * the host page instead of the main process.
+   */
+  sendToHost(e, ...s) {
+  }
+}
+class d {
+  /**
+   * A key for the inserted CSS that can later be used to remove the CSS via
+   * `webFrame.removeInsertedCSS(key)`.
+   *
+   * Injects CSS into the current web page and returns a unique key for the inserted
+   * stylesheet.
+   */
+  insertCSS(e) {
+    return "";
+  }
+  /**
+   * Changes the zoom factor to the specified factor. Zoom factor is zoom percent
+   * divided by 100, so 300% = 3.0.
+   *
+   * The factor must be greater than 0.0.
+   */
+  setZoomFactor(e) {
+  }
+  /**
+   * Changes the zoom level to the specified level. The original size is 0 and each
+   * increment above or below represents zooming 20% larger or smaller to default
+   * limits of 300% and 50% of original size, respectively.
+   *
+   * **NOTE**: The zoom policy at the Chromium level is same-origin, meaning that
+   * the zoom level for a specific domain propagates across all instances of windows
+   * with the same domain. Differentiating the window URLs will make zoom work
+   * per-window.
+   */
+  setZoomLevel(e) {
+  }
+}
+class P {
+  constructor() {
+    /**
+     * The process.platform property returns a string identifying the operating system platform
+     * on which the Node.js process is running.
+     */
+    t(this, "platform");
+    /**
+     * A list of versions for the current node.js/electron configuration.
+     */
+    t(this, "versions");
+    /**
+     * The process.env property returns an object containing the user environment.
+     */
+    t(this, "env");
+  }
+}
+const f = (r) => {
+  const e = {
+    version: "1.0.0",
+    theme: "light",
+    language: "en",
+    strings: {},
+    showToolsPanel: !0,
+    useHexNumericBase: !0,
+    maxDataBytes: 16,
+    defaultProjectFolder: "",
+    currentProjectFile: "",
+    currentProjectFileName: "",
+    recentProjectFiles: [],
+    closeAppServiceAction: "prompt"
+  };
+  return {
+    ipcRenderer: new v(r ?? e),
+    webFrame: new d(),
+    process: new P()
+  };
+}, w = f();
+export {
+  f as c,
+  w as e
+};

package/dist/controls/CanChannelSelectControl.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Properties of the CanChannelSelectControl React component.
+ */
+export interface CanChannelSelectControlProps {
+    /** Identifier of the selected channel. */
+    channelIdentifier: string;
+    /**
+     * Callback that will be called when a new channel has been selected.
+     * @param identifier The new channel identifier.
+     * @param canFdSupport True if the new CAN channel supports CAN-FD.
+     */
+    onChannelIdentifierChange: (identifier: string, canFdSupport: boolean) => void;
+    /** Set to true to hide all silent channels e.g., when the control is used for selecting output channel. */
+    hideSilentChannels?: boolean;
+    /** Set to true if this control shouldn't be encapsulated inside a SectionControl. */
+    hideSectionControl?: boolean;
+    /** Set to true to disable this control. */
+    disabled?: boolean;
+    /** Set to true if the SectionControl should be collapsible, ignored if hideSectionControl is true. */
+    collapsible?: boolean;
+    /** Current collapse state of the SectionControl. */
+    collapsed?: boolean;
+    /**
+     * Callback that will be called when collapse state has changed.
+     * @param value The new collapse state.
+     */
+    collapsedChange?: (value: boolean) => void;
+}
+/**
+ * Creates an UI control for selecting a CAN channel from the current measurement setup.
+ * @param props Component properties.
+ * @returns The CanChannelSelectControl React component.
+ */
+declare function CanChannelSelectControl({ channelIdentifier, onChannelIdentifierChange, hideSilentChannels, hideSectionControl, disabled, collapsible, collapsed, collapsedChange, }: CanChannelSelectControlProps): import("react/jsx-runtime").JSX.Element;
+export default CanChannelSelectControl;

package/dist/controls/CanIdentifierControl.d.ts

@@ -0,0 +1,176 @@
+/**
+ * This module includes UI controls for editing CAN identifiers.
+ *
+ * To be able to use these controls the CanKingDataProvider component must be present in the
+ * component tree above your component. Normally the CanKingDataProvider is added
+ * at the root of the component tree.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import { PeriodicTransmissionSettings, WriteFrame } from '../models';
+/** Possible CAN identifier types, standard (11-bits) or extended (29-bits). */
+export type canIdentifierType = 'standard' | 'extended';
+/** Possible CAN identifier generator types. */
+type identifierGeneratorType = 'constant' | 'random' | 'scan';
+/**
+ * Properties of the CanIdentifierControl React component.
+ */
+interface CanIdentifierControlProps {
+    /** The current CAN identifier. */
+    canIdentifier: string;
+    /** The current CAN identifier type, 'extended or 'standard'. */
+    canIdentifierType: canIdentifierType;
+    /**
+     * Callback that will be called when the CAN identifier has changed.
+     * @param value The new CAN identifier.
+     */
+    onCanIdentifierChange: (identifier: string, idType: canIdentifierType) => void;
+    /**
+     * Callback that will be called when the errors state has changed.
+     * @param errors The new errors state.
+     */
+    onErrorsChange?: (errors: boolean) => void;
+    /** Set to true if this control shouldn't be encapsulated inside a SectionControl. */
+    hideSection?: boolean;
+    /** Set to true to disable this control. */
+    disabled?: boolean;
+    /** Set to true if the SectionControl should be collapsible, ignored if hideSectionControl is true. */
+    collapsible?: boolean;
+    /** Current collapse state of the SectionControl. */
+    collapsed?: boolean;
+    /**
+     * Callback that will be called when collapse state has changed.
+     * @param value The new collapse state.
+     */
+    collapsedChange?: (value: boolean) => void;
+}
+/**
+ * Creates an UI control for editing a CAN identifier.
+ * @param props Component properties.
+ * @returns The CanIdentifierControl React component.
+ */
+declare function CanIdentifierControl({ canIdentifier, canIdentifierType, onCanIdentifierChange, onErrorsChange, hideSection, disabled, collapsible, collapsed, collapsedChange, }: CanIdentifierControlProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Properties of the CanIdentifierFrameControl React component.
+ */
+interface CanIdentifierFrameControlProps {
+    /** The frame object that holds the CAN identifier. */
+    frame: WriteFrame;
+    /**
+     * Callback that will be called when the frame is updated after the CAN identifier has changed.
+     * @param value The new frame object.
+     */
+    onFrameChange: (value: WriteFrame) => void;
+    /**
+     * Callback that will be called when the errors state has changed.
+     * @param errors The new errors state.
+     */
+    onErrorsChange?: (errors: boolean) => void;
+    /** Set to true if the SectionControl should be collapsible. */
+    collapsible?: boolean;
+    /** Current collapse state of the SectionControl. */
+    collapsed?: boolean;
+    /**
+     * Callback that will be called when collapse state has changed.
+     * @param value The new collapse state.
+     */
+    collapsedChange?: (value: boolean) => void;
+}
+/**
+ * Creates an UI control for editing a CAN identifier using a Frame as source.
+ * @param props Component properties.
+ * @returns The CanIdentifierFrameControl React component.
+ */
+declare function CanIdentifierFrameControl({ frame, onFrameChange, onErrorsChange, collapsible, collapsed, collapsedChange, }: CanIdentifierFrameControlProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Properties of the CanIdentifierGeneratorControl React component.
+ */
+interface CanIdentifierGeneratorControlProps {
+    /** The CAN identifier. */
+    canIdentifier: string;
+    /**
+     * The generator type: 'constant' | 'random' | 'scan'
+     * 'constant': The CAN identifier set to canIdentifier will be used for all generated messages.
+     * 'random': A random CAN identifier between minCanIdentifier and maxCanIdentifier will be used.
+     * 'scan': A CAN identifier will be picked from minCanIdentifier to maxCanIdentifier.
+     */
+    identifierGeneratorType: identifierGeneratorType;
+    /** The min CAN identifier that will be used if identifierGeneratorType is 'random' or 'scan'. */
+    minCanIdentifier: string;
+    /** The max CAN identifier that will be used if identifierGeneratorType is 'random' or 'scan'. */
+    maxCanIdentifier: string;
+    /** The CAN identifier type that will be used, 'extended' or 'standard'. */
+    canIdentifierType: canIdentifierType;
+    /**
+     * Callback that will be called when the CAN identifier(s) has changed.
+     * @param newCanIdentifier The new constant CAN identifier.
+     * @param newIdentifierGeneratorType The new generator type.
+     * @param newMinCanIdentifier The new min CAN identifier.
+     * @param newMaxCanIdentifier The new max CAN identifier.
+     */
+    onChange: (newCanIdentifier: string, newIdentifierGeneratorType: identifierGeneratorType, newMinCanIdentifier: string, newMaxCanIdentifier: string, newIdentifierType: canIdentifierType) => void;
+    /**
+     * Callback that will be called when the errors state has changed.
+     * @param errors The new errors state.
+     */
+    onErrorsChange?: (errors: boolean) => void;
+    /** The current error state. */
+    canIdentifierGeneratorSettingsError?: React.MutableRefObject<boolean>;
+    /** Set to true to disable this control. */
+    disabled?: boolean;
+    /** Set to true if the SectionControl should be collapsible. */
+    collapsible?: boolean;
+    /** Current collapse state of the SectionControl. */
+    collapsed?: boolean;
+    /**
+     * Callback that will be called when collapse state has changed.
+     * @param value The new collapse state.
+     */
+    collapsedChange?: (value: boolean) => void;
+}
+/**
+ * Creates an UI control for editing CAN identifier(s) used by a message generator.
+ * @param props Component properties.
+ * @returns The CanIdentifierGeneratorControl React component.
+ */
+declare function CanIdentifierGeneratorControl({ canIdentifier, identifierGeneratorType, minCanIdentifier, maxCanIdentifier, canIdentifierType, onChange, onErrorsChange, canIdentifierGeneratorSettingsError, disabled, collapsible, collapsed, collapsedChange, }: CanIdentifierGeneratorControlProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Properties of the CanIdentifierGeneratorSettingsControl React component.
+ */
+interface CanIdentifierGeneratorSettingsControlProps {
+    /** The settings object that holds the CAN identifier(s) generator settings. */
+    settings: PeriodicTransmissionSettings;
+    /**
+     * Callback that will be called when the settings are updated after the CAN identifiers have changed.
+     * @param value The new settings object.
+     */
+    onSettingsChange: (value: PeriodicTransmissionSettings) => void;
+    /**
+     * Callback that will be called when the errors state has changed.
+     * @param errors The new errors state.
+     */
+    onErrorsChange?: (errors: boolean) => void;
+    /** The current error state. */
+    canIdentifierGeneratorSettingsError?: React.MutableRefObject<boolean>;
+    /** Set to true to disable this control. */
+    disabled?: boolean;
+    /** Set to true if the SectionControl should be collapsible. */
+    collapsible?: boolean;
+    /** Current collapse state of the SectionControl. */
+    collapsed?: boolean;
+    /**
+     * Callback that will be called when collapse state has changed.
+     * @param value The new collapse state.
+     */
+    collapsedChange?: (value: boolean) => void;
+}
+/**
+ * Creates an UI control for editing CAN identifier(s) used by a message generator
+ * using a PeriodicTransmissionSettings as source.
+ * @param props Component properties.
+ * @returns The CanIdentifierGeneratorSettingsControl React component.
+ */
+declare function CanIdentifierGeneratorSettingsControl({ settings, onSettingsChange, onErrorsChange, canIdentifierGeneratorSettingsError, disabled, collapsible, collapsed, collapsedChange, }: CanIdentifierGeneratorSettingsControlProps): import("react/jsx-runtime").JSX.Element;
+export default CanIdentifierControl;
+export { type CanIdentifierControlProps, CanIdentifierControl, type CanIdentifierFrameControlProps, CanIdentifierFrameControl, type CanIdentifierGeneratorControlProps, CanIdentifierGeneratorControl, type CanIdentifierGeneratorSettingsControlProps, CanIdentifierGeneratorSettingsControl, };