@microsoft/dragon-copilot-sdk-lexical-react 1.0.0 → 1.0.1

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/helpers.js

@@ -0,0 +1 @@
+import{logger as t}from"../logger/logging";import{Attr_CustomContainerId as e,Attr_CustomContainerType as n,SharedData as o}from"../shared-data";import{getAttributeValue as r}from"../webtcl/webtcl-attributes";export function getCustomContainerType(t){const e=t===null||t===void 0?void 0:t.getAttribute(n);return e!==null&&e!==void 0?e:null}export function getCustomControlType(t){if(!t){return null}return r(t,"customControlType")}export function getCustomContainerId(t){const n=t===null||t===void 0?void 0:t.getAttribute(e);return n!==null&&n!==void 0?n:null}export function getCustomControlContainer(t){const e=getCustomContainerId(t);return e?o.activeDocument.getElementById(e):null}export function getTinyMceEditor(e){if(typeof tinymce==="undefined")return null;for(const n of tinymce.get()){if(e.nodeName=="IFRAME"&&n.getContentAreaContainer().contains(e)){t.debug("helpers:getTinyMceEditor","TinyMCE control found:",e.tagName,e.id);return n}if(n.getBody()===e){t.debug("helpers:getTinyMceEditor","TinyMCE control found:",e.tagName,e.id);return n}}return null}

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/index.d.ts

@@ -0,0 +1,6 @@
+export type { TextControl } from "./text-control";
+export { createTextControl } from "./factory";
+export { getTinyMceEditor, getCustomControlType, getCustomContainerType, getCustomControlContainer } from "./helpers";
+export type { ProcessingStatus } from "./processing-status";
+export { TextControlManager, textControlManager } from "./text-control-manager";
+export { CustomControl } from "./custom-control";

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/index.js

@@ -0,0 +1 @@
+export{createTextControl}from"./factory";export{getTinyMceEditor,getCustomControlType,getCustomContainerType,getCustomControlContainer}from"./helpers";export{TextControlManager,textControlManager}from"./text-control-manager";export{CustomControl}from"./custom-control";

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/input-control.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The Input control class
+ * @class
+ */
+export class InputControl extends BaseControl {
+}
+import { BaseControl } from "./base-control";

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/input-control.js

@@ -0,0 +1 @@
+import{BaseControl as t}from"./base-control";export class InputControl extends t{constructor(t){super(t);this.type="Input";this.isMultiline=false}}

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/processing-status.d.ts

@@ -0,0 +1 @@
+export type ProcessingStatus = "pending" | "idle";

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/processing-status.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/text-control-manager.d.ts

@@ -0,0 +1,38 @@
+import type { TextControl } from "./text-control";
+/**
+ * @class
+ */
+export declare class TextControlManager {
+    #private;
+    get textControlCount(): number;
+    /**
+     *
+     * @param {TextControl} textControl
+     * @param {string|null} controlId
+     * @return {string} the controlId
+     */
+    addTextControl(textControl: TextControl, controlId?: string, containerId?: string): string;
+    /**
+     * returns a copy of the textControls
+     * @return {TextControl[]}
+     */
+    getTextControls(): TextControl[];
+    /**
+     *
+     * @param controlId
+     * @return {TextControl|null}
+     */
+    getTextControl(controlId: string): TextControl | null;
+    /** @returns {TextControl|null} */
+    getFirstTextControl(): TextControl | null;
+    /**
+     *
+     * @param element
+     * @return {TextControl|null}
+     */
+    getTextControlByElement(element: HTMLElement): TextControl | null;
+    removeTextControl(controlId: string): boolean;
+    removeAll(): void;
+    getContainers(): Record<string, string>;
+}
+export declare const textControlManager: TextControlManager;

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/text-control-manager.js

@@ -0,0 +1 @@
+var t,e;import{__classPrivateFieldGet as r}from"tslib";import*as o from"../common/util";import*as n from"../common/string";import{getAttributeValue as s}from"../webtcl/webtcl-attributes";export class TextControlManager{constructor(){t.set(this,new Map);e.set(this,new Map)}get textControlCount(){return r(this,t,"f").size}addTextControl(s,l="",i=""){if(n.isEmpty(l))l=o.Instance.createGuid();s.setGuid(l);r(this,e,"f").set(l,i);r(this,t,"f").set(l,s);return l}getTextControls(){return Array.from(r(this,t,"f").values())}getTextControl(e){var o;return(o=r(this,t,"f").get(e))!==null&&o!==void 0?o:null}getFirstTextControl(){const e=r(this,t,"f").values().next();return!e.done?e.value:null}getTextControlByElement(e){var o;const n=s(e,"controlId");if(!n){return null}return(o=r(this,t,"f").get(n))!==null&&o!==void 0?o:null}removeTextControl(o){var n;(n=r(this,t,"f").get(o))===null||n===void 0?void 0:n.invalidate();r(this,e,"f").delete(o);return r(this,t,"f").delete(o)}removeAll(){r(this,e,"f").clear();r(this,t,"f").forEach(t=>t.invalidate());r(this,t,"f").clear()}getContainers(){const t={};for(const[o,n]of r(this,e,"f").entries()){t[o]=n}return t}}t=new WeakMap,e=new WeakMap;export const textControlManager=new TextControlManager;

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/text-control.d.ts

@@ -0,0 +1,64 @@
+import type { ProcessingStatus } from "./processing-status";
+import type { AdditionalReplaceTextParameters } from "../webtcl/types";
+/**
+ * Represents the set of additional capabilities supported by some text-controls.
+ *
+ * @property undoRedo - Indicates whether undo and redo operations are supported.
+ */
+export type UndoableControl = {
+    undo(): void;
+    redo(): void;
+} & TextControl;
+/**
+ * Represents the set of additional/custom features supported by a text control.
+ *
+ * @property undoRedo - Indicates whether undo and redo functionality is available.
+ */
+export type Capabilities = {
+    undoRedo: boolean;
+};
+/**
+ * TextControl interface.
+ * Contains all public members used in SpeechDocument.
+ * DO NOT extend this type!
+ */
+export type TextControl = {
+    readonly type: string;
+    readonly guid: string | null;
+    readonly htmlElement: HTMLElement;
+    readonly newlineFormat: string;
+    readonly paragraphFormat: string;
+    readonly conceptName: string | undefined;
+    readonly dictationMode: string | undefined;
+    readonly documentFieldId: string | undefined;
+    readonly isMultiline: boolean;
+    readonly capabilities?: Capabilities;
+    onFocus: ((e: FocusEvent) => void) | null;
+    onBlur: ((e: FocusEvent) => void) | null;
+    onElementFocus(e: Event | null): void;
+    invalidate(): void;
+    isValid(): boolean;
+    cleanup(initial: boolean): void;
+    setGuid(guid: string): void;
+    getText(): string;
+    replaceText(text: string, start: number, length: number, additionalParameters?: AdditionalReplaceTextParameters): boolean;
+    setText(text: string): void;
+    getSelection(): {
+        start: number;
+        length: number;
+    };
+    setSelection(start: number, length: number): void;
+    getProcessingStatus(): ProcessingStatus;
+    setProcessingStatus(status: ProcessingStatus): void;
+};
+/**
+ * Determines whether the given `TextControl` implements the `UndoableControl` interface.
+ *
+ * This function checks if the control has the `undoRedo` capability enabled and
+ * verifies that both `undo` and `redo` methods are present and are functions.
+ * If the capability or methods are missing, a warning is logged.
+ *
+ * @param control - The `TextControl` instance to check.
+ * @returns `true` if the control implements `UndoableControl`, otherwise `false`.
+ */
+export declare function isUndoableControl(control: TextControl): control is UndoableControl;

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/text-control.js

@@ -0,0 +1 @@
+import{logger as o}from"../logger/logging";export function isUndoableControl(n){var i;if(!((i=n.capabilities)===null||i===void 0?void 0:i.undoRedo)){o.warning("isUndoableControl","undoReo capability not set");return false}const r="undo"in n&&typeof n.undo==="function"&&"redo"in n&&typeof n.redo==="function";if(!r){o.warning("isUndoableControl","undo or redo function not provided by control")}return r}

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/textarea-control.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The TextArea control class
+ * @class
+ */
+export class TextAreaControl extends BaseControl {
+}
+import { BaseControl } from "./base-control";

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/textarea-control.js

@@ -0,0 +1 @@
+import{BaseControl as t}from"./base-control";export class TextAreaControl extends t{constructor(t){super(t);this.type="TextArea"}}

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/tinymce-control.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The TinyMCE control class
+ * @class
+ */
+export class TinyMceControl extends ContentEditableControl {
+    tinyMceIframe: any;
+    tinyMceEditor: any;
+    adjustScrollPosition(): void;
+    #private;
+}
+import { ContentEditableControl } from "./contenteditable-control";

package/node_modules/@hccm/web-tcl/dist/esm/text-control-lib/tinymce-control.js

@@ -0,0 +1 @@
+var t,e,n;import{__classPrivateFieldGet as i}from"tslib";import{ContentEditableControl as o}from"./contenteditable-control";import{logger as c}from"../logger/logging";export class TinyMceControl extends o{constructor(e){super(e.getBody());t.add(this);this.tinyMceIframe=e.iframeElement;this.type="TinyMCE";this.tinyMceEditor=e}replaceText(t,e,n){this.tinyMceEditor.undoManager.beforeChange();const i=super.replaceText(t,e,n);if(this.htmlElement.childElementCount===0){this.htmlElement.innerHTML="<p><br></p>"}return i}setSelection(t=0,e=0){super.setSelection(t,e);this.tinyMceEditor.undoManager.add()}getSelectionCoordinates(){if(this.tinyMceIframe){const t=this.tinyMceIframe.getBoundingClientRect();const e=this.tinyMceIframe.contentWindow.getSelection();if(!e||e.rangeCount===0)return null;const n=e.getRangeAt(0).getBoundingClientRect();return{left:t.left+n.left,top:t.top+n.top,right:t.left+n.right,bottom:t.top+n.bottom}}return super.getSelectionCoordinates()}adjustScrollPosition(){try{if(!i(this,t,"m",n).call(this)){this.tinyMceEditor.getContainer().scrollIntoView()}const o=i(this,t,"m",e).call(this);const c=this.tinyMceEditor.getWin();const r=c.document.documentElement;if(!r||!o)return;const s=r.scrollTop;const l=s+r.clientHeight;const d=o.top+s;const g=o.bottom+s;if(d<s){c.scrollTo(0,d)}else if(g>l){const t=g-r.clientHeight;c.scrollTo(0,t)}}catch(t){c.error("TinyMceControl.adjustScrollPosition","Error adjusting scroll position",t)}}}t=new WeakSet,e=function t(){let e=this.tinyMceEditor.selection.getBoundingClientRect();if(!e){if(this.tinyMceEditor.selection.isCollapsed()){c.debug("TinyMceControl.#getBoundingClientRectOfEditor","rect is undefined, expanding selection to get rect");const t=this.tinyMceEditor.selection.getRng();this.tinyMceEditor.selection.expand();e=this.tinyMceEditor.selection.getBoundingClientRect();this.tinyMceEditor.selection.collapse(t.startContainer,t.startOffset)}if(!e){c.debug("TinyMceControl.#getBoundingClientRectOfEditor","Could not adjust scroll position as rect is undefined")}}return e},n=function t(){if(!this.tinyMceEditor)return false;const e=document.getElementById(this.tinyMceEditor.id).clientHeight;const n=this.tinyMceEditor.getContainer();const i=n.getBoundingClientRect();const o=0;const c=window.innerHeight||document.documentElement.clientHeight;const r=i.top>=o&&i.top<=c;const s=i.bottom>=o&&i.bottom<=c;const l=e>window.innerHeight;return r&&s||l};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/channel.d.ts

@@ -0,0 +1,15 @@
+import { type NextObserver, type Observable } from "rxjs";
+export type Typed<TMap> = {
+    [K in keyof TMap]: {
+        type: K;
+    };
+};
+export type ChannelSender<TMessageMap extends Typed<TMessageMap>> = {
+    send(this: void, message: TMessageMap[keyof TMessageMap]): void;
+};
+export type ChannelReceiver<TMessageMap extends Typed<TMessageMap>> = {
+    receiveAll(this: void): Observable<TMessageMap[keyof TMessageMap]>;
+    receive<K extends keyof TMessageMap>(this: void, type: K): Observable<TMessageMap[K]>;
+};
+export declare function channelSender<TMessageMap extends Typed<TMessageMap>>(value: NextObserver<TMessageMap[keyof TMessageMap]>): ChannelSender<TMessageMap>;
+export declare function channelReceiver<TMessageMap extends Typed<TMessageMap>>(value$: Observable<TMessageMap[keyof TMessageMap]>): ChannelReceiver<TMessageMap>;

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/channel.js

@@ -0,0 +1 @@
+import{filter as e}from"rxjs";export function channelSender(e){return{send(r){e.next(r)}}}export function channelReceiver(r){return{receiveAll(){return r},receive(n){return r.pipe(e(e=>e.type===n))}}}

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/commands.d.ts

@@ -0,0 +1,64 @@
+import type { ProcessingStatus } from "./processing-status";
+import type { AdditionalReplaceTextParameters } from "./types";
+type CommandMap = {
+    initialize: {
+        isDisabled: boolean;
+        useGuiMarkup: boolean;
+    };
+    dispose: undefined;
+    focus: {
+        id: string;
+    };
+    activate: {
+        id: string;
+    };
+    deactivate: {
+        id: string;
+    };
+    selectNode: {
+        id: string;
+        shouldFocus: boolean;
+    };
+    setStatus: {
+        id: string;
+        status: ProcessingStatus;
+    };
+    replaceText: {
+        id: string;
+        text: string;
+        selection: {
+            start: number;
+            length: number;
+        };
+        additionalParameters?: AdditionalReplaceTextParameters;
+    };
+    setSelection: {
+        id: string;
+        selection: {
+            start: number;
+            length: number;
+        };
+    };
+    setText: {
+        id: string;
+        text: string;
+    };
+    setRecordingState: {
+        state: "started" | "stopped";
+    };
+    undo: {
+        id: string;
+    };
+    redo: {
+        id: string;
+    };
+};
+export type WebTCLCommands = {
+    [K in keyof CommandMap]: CommandMap[K] extends undefined ? {
+        type: K;
+    } : {
+        type: K;
+    } & CommandMap[K];
+};
+export type WebTCLCommand = WebTCLCommands[keyof WebTCLCommands];
+export {};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/commands.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/custom-control.d.ts

@@ -0,0 +1,212 @@
+import type { Capabilities } from "../../text-control-lib/text-control";
+import type { AdditionalReplaceTextParameters } from "../types";
+/**
+ * A command indicates what changed on the custom-control
+ */
+export type CustomControlCommand = {
+    /**
+     * The text to replace.
+     */
+    text: {
+        value: string;
+        start: number;
+        length: number;
+        additionalParameters?: AdditionalReplaceTextParameters;
+    };
+    /**
+     * The selection of the text.
+     */
+    selection: {
+        start: number;
+        end: number;
+    };
+    /**
+     * Indicates if the custom-control should be focused or not.
+     */
+    focus: boolean;
+    /**
+     * Forwards the undo voice command to the custom control.
+     */
+    undo: undefined;
+    /**
+     * Forwards the redo voice command to the custom control.
+     */
+    redo: undefined;
+};
+/**
+ * Represents the state of a custom control.
+ */
+export type CustomControlState = {
+    /**
+     * The text content of the custom-control
+     */
+    text: string;
+    /**
+     * The selection of the text
+     */
+    selection: {
+        start: number;
+        end: number;
+    };
+    /**
+     * Indicates if the custom-control has the focus or not.
+     */
+    focus: boolean;
+};
+/**
+ * Custom Control
+ */
+export interface CustomControl {
+    /**
+     * Used to synchronize changes from the {@link CustomControl} with the {@link HTMLElement}
+     * @param type {@link CustomControlCommand} indicates what changed
+     * @param action The function to execute for the given {@param type}
+     */
+    handle<K extends keyof CustomControlCommand>(type: K, action: (command: CustomControlCommand[K]) => void): void;
+    /**
+     * Used to synchronize changes from the {@link HTMLElement} with the {@link CustomControl}
+     * @param changes indicates what changed
+     */
+    update(changes: Partial<CustomControlState>): void;
+    /**
+     * Defines new line characters
+     * @default "\n"
+     * @example
+     * ```ts
+     *  function(element: HTMLElement, control: CustomControl) {
+     *    control.newline = "\n";
+     *  }
+     * ```
+     */
+    newline: string;
+    /**
+     * Defines paragraph characters
+     * @default "\n\n"
+     * @example
+     * ```ts
+     *  function (element: HTMLElement, control: CustomControl) {
+     *    control.paragraph = "\n\n";
+     *  }
+     * ```
+     */
+    paragraph: string;
+    /**
+     * Indicates if the control is multiline or not
+     * @default false
+     * @example
+     * ```ts
+     *  function (element: HTMLElement, control: CustomControl) {
+     *    control.isMultiline = true;
+     *  }
+     * ```
+     */
+    isMultiline: boolean;
+    /**
+     * Represents the set of additional/custom features supported by a custom control.
+     *
+     * @property undoRedo - Indicates whether undo and redo functionality is available.
+     * @example
+     * ```ts
+     *  function (element: HTMLElement, control: CustomControl) {
+     *    control.capabilities = {
+     *      undoRedo: true
+     *    }
+     *  }
+     * ```
+     */
+    capabilities?: Capabilities;
+}
+/**
+ * Binds {@link HTMLElement} to {@link CustomControl}, synchronizing their state.
+ * Changes happened in {@link HTMLElement} are propagate to {@link CustomControl}, and vice-versa.
+ * - Initializes {@link CustomControl} with initial state of {@link HTMLElement}
+ * - Set event handlers from {@link CustomControl}, applying changes to {@link HTMLElement}
+ * - Set event handlers from {@link HTMLElement}, applying changes to {@link CustomControl}
+ * - Return a function to disconnect {@link HTMLElement} and {@link CustomControl}.
+ *
+ * @example
+ * ```ts
+ *  const customInput: CustomControlInitializer = (element, control) => {
+ *    if (!(element instanceof HTMLInputElement)) {
+ *      throw new Error("Element is not an input element");
+ *    }
+ *
+ *    // configure the custom control
+ *    control.update({
+ *      newline: "\n",
+ *      paragraph: "\n\n",
+ *    });
+ *
+ *    const updateCustomControl = () => {
+ *      control.update({
+ *        text: element.value,
+ *        selection: {
+ *          start: element.selectionStart ?? 0,
+ *          length: (element.selectionEnd ?? 0) - (element.selectionStart ?? 0),
+ *        },
+ *        focus: element === element.ownerDocument.activeElement,
+ *      });
+ *    };
+ *
+ *    // initial state for web-tcl
+ *    updateCustomControl();
+ *
+ *    // handle events coming from web-tcl
+ *    control.handle("selection", ({ start, end }) => {
+ *      element.setSelectionRange(start, end);
+ *    });
+ *
+ *    control.handle("text", ({ value, start, length }) => {
+ *      if (!value) {
+ *        element.value = "";
+ *      } else {
+ *        element.value = `${element.value.slice(0, start)}${value}${element.value.slice(start + length)}`;
+ *      }
+ *      element.dispatchEvent(new Event("change", { bubbles: true }));
+ *    });
+ *
+ *    control.handle("focus", (focus) => {
+ *      if (focus) {
+ *        element.focus();
+ *      } else {
+ *        element.blur();
+ *      }
+ *    });
+ *
+ *    // handle events coming from the HTML element
+ *    element.addEventListener("input", notifyCustomControl);
+ *    element.addEventListener("change", notifyCustomControl);
+ *    element.addEventListener("select", notifyCustomControl);
+ *    element.addEventListener("focusin", notifyCustomControl);
+ *    element.addEventListener("focusout", notifyCustomControl);
+ *
+ *    return function () {
+ *      element.removeEventListener("input", notifyCustomControl);
+ *      element.removeEventListener("change", notifyCustomControl);
+ *      element.removeEventListener("select", notifyCustomControl);
+ *      element.removeEventListener("focusin", notifyCustomControl);
+ *      element.removeEventListener("focusout", notifyCustomControl);
+ *    };
+ *  };
+ * ```
+ * @param element
+ * @param control
+ * @returns a function to remove event handlers, disconnecting {@link HTMLElement} and {@link CustomControl}.
+ */
+export type CustomControlInitializer = (element: HTMLElement, control: CustomControl) => () => void;
+/**
+ * Collection of {@link CustomControl} - key is string, value is {@link CustomControlInitializer}
+ * @example
+ * ```ts
+ *  const customControls = {
+ *    "customControlType": function (element: HTMLElement, control: CustomControl) {
+ *      // implementation
+ *    },
+ *  }
+ * ```
+ */
+export interface CustomControlCollection {
+    readonly [name: string]: CustomControlInitializer;
+    readonly [name: number]: never;
+    readonly [name: symbol]: never;
+}

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/custom-control.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/index.d.ts

@@ -0,0 +1,6 @@
+import type { CustomControl, CustomControlInitializer, CustomControlCollection, CustomControlCommand, CustomControlState } from "./custom-control";
+export type { CustomControl, CustomControlInitializer, CustomControlCollection, CustomControlCommand, CustomControlState, };
+export declare const CustomControls: {
+    readonly inputCustomControl: CustomControlInitializer;
+    readonly textareaCustomControl: CustomControlInitializer;
+};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/index.js

@@ -0,0 +1 @@
+import{inputCustomControl as o}from"./input-custom-control";import{textareaCustomControl as t}from"./textarea-custom-control";export const CustomControls={inputCustomControl:o,textareaCustomControl:t};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/input-custom-control.d.ts

@@ -0,0 +1,2 @@
+import type { CustomControlInitializer } from "./custom-control";
+export declare const inputCustomControl: CustomControlInitializer;

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/input-custom-control.js

@@ -0,0 +1 @@
+export const inputCustomControl=function(e,n){if(!(e instanceof HTMLInputElement)){throw new Error("Element must be an input")}n.newline="\n";n.paragraph="\n\n";n.isMultiline=false;const t=()=>{var t,s;n.update({text:e.value,selection:{start:(t=e.selectionStart)!==null&&t!==void 0?t:0,end:(s=e.selectionEnd)!==null&&s!==void 0?s:0},focus:e===e.ownerDocument.activeElement})};t();n.handle("text",({value:n,start:t,length:s})=>{e.value=e.value.slice(0,t)+n+e.value.slice(t+s);e.dispatchEvent(new Event("change",{bubbles:true}))});n.handle("selection",({start:n,end:t})=>{e.setSelectionRange(n,t)});n.handle("focus",n=>{if(n){e.focus()}else{e.blur()}});e.addEventListener("input",t);e.addEventListener("change",t);e.addEventListener("select",t);e.addEventListener("focusin",t);e.addEventListener("focusout",t);return function(){e.removeEventListener("input",t);e.removeEventListener("change",t);e.removeEventListener("select",t);e.removeEventListener("focusin",t);e.removeEventListener("focusout",t)}};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/textarea-custom-control.d.ts

@@ -0,0 +1,2 @@
+import type { CustomControlInitializer } from "./custom-control";
+export declare const textareaCustomControl: CustomControlInitializer;

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/custom-controls/textarea-custom-control.js

@@ -0,0 +1 @@
+export const textareaCustomControl=function(e,t){if(!(e instanceof HTMLTextAreaElement)){throw new Error("Element must be an input")}t.newline="\n";t.paragraph="\n\n";t.isMultiline=true;const n=()=>{var n,s;t.update({text:e.value,selection:{start:(n=e.selectionStart)!==null&&n!==void 0?n:0,end:(s=e.selectionEnd)!==null&&s!==void 0?s:0},focus:e===e.ownerDocument.activeElement})};n();t.handle("text",({value:t,start:n,length:s})=>{e.value=e.value.slice(0,n)+t+e.value.slice(n+s);e.dispatchEvent(new Event("change",{bubbles:true}))});t.handle("selection",({start:t,end:n})=>{e.setSelectionRange(t,n)});t.handle("focus",t=>{if(t){e.focus()}else{e.blur()}});e.addEventListener("input",n);e.addEventListener("change",n);e.addEventListener("select",n);e.addEventListener("focusin",n);e.addEventListener("focusout",n);return function(){e.removeEventListener("input",n);e.removeEventListener("change",n);e.removeEventListener("select",n);e.removeEventListener("focusin",n);e.removeEventListener("focusout",n)}};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/diagnostics.d.ts

@@ -0,0 +1,37 @@
+import type { WebTCLCommand } from "./commands";
+import { type WebTCLEvent } from "./events";
+import type { WebTCLState } from "./state";
+type Diagnostics = {
+    isEnabled: true;
+    trace(message: DiagnosticMessage): void;
+} | {
+    isEnabled: false;
+};
+export declare function createDiagnostics(): Diagnostics;
+export type DiagnosticMessageMap = {
+    "worker-created": object;
+    "worker-destroyed": object;
+    "command-executing": {
+        command: WebTCLCommand;
+    };
+    "command-executed": {
+        command: WebTCLCommand;
+    };
+    "state-changed": {
+        state: WebTCLState;
+        newState: WebTCLState;
+        trigger: WebTCLEvent;
+    };
+    "event-dispatching": {
+        event: WebTCLEvent;
+    };
+    "event-dispatched": {
+        event: WebTCLEvent;
+    };
+};
+export type DiagnosticMessage = {
+    [K in keyof DiagnosticMessageMap]: {
+        type: K;
+    } & DiagnosticMessageMap[K];
+}[keyof DiagnosticMessageMap];
+export {};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/diagnostics.js

@@ -0,0 +1 @@
+import{name as e,version as t}from"../package-info";import{currentTimestamp as s}from"./events";let n=0;export function createDiagnostics(){var o;const r=n++;switch((o=sessionStorage.getItem("WEBTCL_ENABLE_DIAGNOSTICS"))!==null&&o!==void 0?o:""){case"console":{let n=0;return{isEnabled:true,trace(o){const a=n++;console.log("%s@%s:[%d][%d]:%s at %f\n%s",e,t,r,a,o.type,s(),JSON.stringify(o,null,2))}}}default:return{isEnabled:false}}}

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/dom-observable.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from "rxjs";
+export type ControlsMutation = {
+    type: "childList";
+    target: HTMLElement;
+    added: HTMLElement[];
+    removed: HTMLElement[];
+} | {
+    type: "attributes";
+    target: HTMLElement;
+    attributeName: string;
+};
+export declare const attributesToObserve: ("data-dragon-container" | "data-nusa-container" | "data-dragon-concept-name" | "data-nusa-concept-name" | "data-dragon-enabled" | "data-nusa-enabled")[];
+export declare function createDomObservable(target: Node): Observable<ControlsMutation>;

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/dom-observable.js

@@ -0,0 +1 @@
+import{Observable as t}from"rxjs";import{DragonAttributesMap as e}from"./webtcl-attributes";export const attributesToObserve=[...e.container,...e.conceptName,...e.isEnabled];export function createDomObservable(e){return new t(t=>{const r=new MutationObserver(e=>{e.forEach(e=>{if(!e.target||e.target.nodeType!==Node.ELEMENT_NODE){return}if(e.type==="childList"){const r=Array.from(e.addedNodes).filter(t=>t.nodeType===Node.ELEMENT_NODE);const o=Array.from(e.removedNodes).filter(t=>t.nodeType===Node.ELEMENT_NODE);if(r.length===0&&o.length===0){return}t.next({type:"childList",target:e.target,added:r,removed:o})}if(e.type==="attributes"&&e.attributeName){t.next({type:"attributes",target:e.target,attributeName:e.attributeName})}})});const o={childList:true,subtree:true,attributes:true,attributeFilter:attributesToObserve};r.observe(e,o);return()=>{r.disconnect()}})}

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/events.d.ts

@@ -0,0 +1,39 @@
+import type { ProcessingStatus } from "./processing-status";
+import type { WebTCLState } from "./state";
+type EventMap = {
+    initialized: Pick<WebTCLState, "isInitialized" | "isDisabled">;
+    focusChanged: {
+        id: string;
+        isFocused: boolean;
+    };
+    disposed: undefined;
+    controlChanged: {
+        id: string;
+        text: string;
+        selection: {
+            start: number;
+            length: number;
+        };
+    };
+    statusChanged: {
+        id: string;
+        status: ProcessingStatus;
+    };
+    controlsChanged: Pick<WebTCLState, "textControls" | "focusedControl">;
+};
+export type WebTCLEvents = {
+    [K in keyof EventMap]: EventMap[K] extends undefined ? {
+        type: K;
+        timestamp: number;
+    } : {
+        type: K;
+        timestamp: number;
+    } & EventMap[K];
+};
+export type WebTCLEvent = WebTCLEvents[keyof WebTCLEvents];
+/**
+ * Get the current time in high resolution milliseconds
+ * @returns the current time in milliseconds
+ */
+export declare const currentTimestamp: () => number;
+export {};

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/events.js

@@ -0,0 +1 @@
+export const currentTimestamp=()=>performance.timeOrigin+performance.now();

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/iframe-support.d.ts

@@ -0,0 +1,29 @@
+import type { CustomControlCollection } from "./custom-controls";
+/**
+ * Options for configuring iframe message handling.
+ *
+ * @property contextWindow - The window context in which the iframe is running.
+ * @property customControls - (Optional) A collection of custom controls to be used within the iframe.
+ */
+export type IframeMessagesOptions = {
+    contextWindow: Window;
+    customControls?: CustomControlCollection;
+};
+/**
+ * Subscribes to messages sent to the current window from its parent and forwards them as commmands to the web-tcl client.
+ * It also subscribes to events coming from the web-tcl client and fowards them to its parent as messages.
+ *
+ * @remarks
+ * **IMPORTANT:** This function should only be called when running inside an iframe.
+ *
+ * - Listens for messages from the parent window and forwards them to the WebTCL client.
+ * - Forwards events from the WebTCL client back to the parent window using `postMessage`.
+ * - Manages all subscriptions and resources, cleaning them up when the returned unsubscribe function is called.
+ *
+ * @param options - Configuration options for the subscription.
+ * @param options.contextWindow - The window context in which the iframe is running.
+ * @param options.customControls - (Optional) A collection of custom control types to be used within the iframe.
+ * @returns A cleanup function that unsubscribes from all events and disposes the WebTCL client.
+ * @throws Error if called outside of an iframe context.
+ */
+export declare function subscribeToIframeMessages({ contextWindow, customControls }: IframeMessagesOptions): () => void;

package/node_modules/@hccm/web-tcl/dist/esm/webtcl/iframe-support.js

@@ -0,0 +1 @@
+import{fromEvent as e,Subscription as r}from"rxjs";import{createClient as s}from"./webtcl-client";import{createController as t}from"./webtcl-controller";import{SpeechDocument as o}from"../speech-document";import{logger as n}from"../logger/logging";export function subscribeToIframeMessages({contextWindow:i,customControls:m}){if(!a(i)){throw Error("Not running inside an iframe")}const u=t({speechdocument:new o({customControls:m})});const c=s({controller:u});const p=new r;let d="";function f(e){try{if(!d){n.warning("iframe-support.sendToParent","originOfSubscriber is not set");return}i.parent.postMessage(e,d)}catch(e){n.error("iframe-support.subscribeToIframeMessages","Failed to send message to parent:",e)}}const g=e(i,"message");p.add(g.subscribe(e=>{if(!e.data){n.debug("iframe-support.messages$.subscribe","message.data is empty");return}if(e.source!==i.parent){n.debug("iframe-support.messages$.subscribe",`message is not from parent`);return}if(!u.isValidCommand(e.data)){n.debug("iframe-support.messages$.subscribe","message.data is not a valid WebTCLCommand");return}if(e.data.type==="initialize"){d=e.origin}c.commands.send(e.data)}));p.add(c.events.receiveAll().subscribe(e=>{f(e)}));i.parent.postMessage({type:"dragon-iframe-support-ready"},"*");return()=>{c.dispose();p.unsubscribe()}}function a(e){try{return e.self!==e.top}catch(e){return true}}