@ale-rainbow/web-sdk 5.1.0

package/lib/utils/browser.d.ts

@@ -0,0 +1,231 @@
+import { BehaviorSubject } from "rxjs";
+/**
+ * Observable that emits the current window size category ('small', 'medium', or 'large').
+ * Automatically updates when the window is resized and crosses size thresholds.
+ *
+ * @example
+ * ```typescript
+ * import { windowSize } from '..';
+ *
+ * windowSize.subscribe(size => {
+ *   console.log('Window size changed to:', size);
+ * });
+ * ```
+ */
+export declare const windowSize: BehaviorSubject<string>;
+/**
+ * Detects if the current browser is Internet Explorer.
+ *
+ * @returns `true` if the browser is Internet Explorer (any version), `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isIEBrowser } from '..';
+ *
+ * if (isIEBrowser()) {
+ *   console.warn('IE is not fully supported');
+ * }
+ * ```
+ */
+export declare function isIEBrowser(): boolean;
+/**
+ * Detects if the current browser is Safari.
+ *
+ * @returns `true` if the browser is Safari, `false` otherwise
+ *
+ * @remarks
+ * Uses the WebRTC adapter's browser detection for accurate Safari identification.
+ *
+ * @example
+ * ```typescript
+ * import { isSafari } from '..';
+ *
+ * if (isSafari()) {
+ *   console.log('Applying Safari-specific workarounds');
+ * }
+ * ```
+ */
+export declare function isSafari(): boolean;
+/**
+ * Detects if the current browser is Firefox.
+ *
+ * @returns `true` if the browser is Firefox, `false` otherwise
+ *
+ * @remarks
+ * Uses the WebRTC adapter's browser detection for accurate Firefox identification.
+ *
+ * @example
+ * ```typescript
+ * import { isFirefox } from '..';
+ *
+ * if (isFirefox()) {
+ *   console.log('Running in Firefox');
+ * }
+ * ```
+ */
+export declare function isFirefox(): boolean;
+/**
+ * Detects if the application is running in a desktop environment (Electron or Qt WebEngine).
+ *
+ * @returns `true` if running in Electron or Qt WebEngine, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isDesktop } from '..';
+ *
+ * if (isDesktop()) {
+ *   console.log('Running as desktop application');
+ * }
+ * ```
+ */
+export declare function isDesktop(): boolean;
+/**
+ * Detects if the application is running on localhost.
+ *
+ * @returns `true` if the hostname is 'localhost', `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isLocalhost } from '..';
+ *
+ * if (isLocalhost()) {
+ *   console.log('Running in development mode');
+ * }
+ * ```
+ */
+export declare function isLocalhost(): boolean;
+/**
+ * Detects the operating system platform from the user agent.
+ *
+ * @returns Platform identifier: 'mac', 'win', 'linux', or 'unknown'
+ *
+ * @example
+ * ```typescript
+ * import { platform } from '..';
+ *
+ * const os = platform();
+ * console.log('Running on:', os);
+ *
+ * if (os === 'mac') {
+ *   console.log('Use Cmd key for shortcuts');
+ * }
+ * ```
+ */
+export declare function platform(): string;
+/**
+ * Detects if the current browser is running on a Linux desktop OS.
+ * Android is explicitly excluded because its user agent also contains the "Linux" token.
+ *
+ * @returns `true` if running on a Linux desktop OS, `false` otherwise
+ *
+ * @remarks
+ * Detection is attempted in the following order:
+ * 1. `navigator.userAgentData.platform` — modern User-Agent Client Hints API (Chrome 90+, Edge 90+), synchronous and not frozen.
+ * 2. `navigator.platform` — legacy API (deprecated but still widely supported), e.g. `"Linux x86_64"`.
+ * 3. `navigator.userAgent` — last-resort string matching, with explicit Android exclusion.
+ *
+ * @example
+ * ```typescript
+ * import { isLinux } from '../utils/browser';
+ *
+ * if (isLinux()) {
+ *   console.log('Applying Linux-specific workaround');
+ * }
+ * ```
+ */
+export declare function isLinux(): boolean;
+/**
+ * Requests access to browser media devices (camera, microphone, screen sharing) with specified constraints.
+ *
+ * @param userMedia - Array of media constraints defining which devices to request
+ * @returns Promise resolving to a MediaStream containing the requested media tracks
+ *
+ * @remarks
+ * This function applies device constraints and settings before requesting media access.
+ * Use {@link getBrowserMediaWithNoConstraints} if you need raw device access without constraints.
+ *
+ * @example
+ * ```typescript
+ * import { getBrowserMedia } from '..';
+ *
+ * // Request camera and microphone
+ * const stream = await getBrowserMedia([
+ *   { audio: true, video: { width: 1280, height: 720 } }
+ * ]);
+ * ```
+ */
+export declare function getBrowserMedia(userMedia: any[]): Promise<MediaStream>;
+/**
+ * Requests access to browser media devices without applying additional constraints.
+ *
+ * @param userMedia - Array of basic media requests (audio/video flags)
+ * @returns Promise resolving to a MediaStream with raw device access
+ *
+ * @remarks
+ * Unlike {@link getBrowserMedia}, this function does not apply device-specific constraints
+ * or settings, providing raw access to media devices.
+ *
+ * @example
+ * ```typescript
+ * import { getBrowserMediaWithNoConstraints } from '..';
+ *
+ * // Request basic camera and microphone access
+ * const stream = await getBrowserMediaWithNoConstraints([
+ *   { audio: true, video: true }
+ * ]);
+ * ```
+ */
+export declare function getBrowserMediaWithNoConstraints(userMedia: any[]): Promise<MediaStream>;
+/**
+ * Copies text content to the system clipboard.
+ *
+ * @param data - The text string to copy to clipboard
+ * @returns Promise that resolves when the text is copied
+ *
+ * @remarks
+ * Automatically falls back to a legacy clipboard method if the Clipboard API is not available.
+ * The fallback uses a temporary textarea element with document.execCommand('copy').
+ *
+ * @example
+ * ```typescript
+ * import { copyTextToClipboard } from '..';
+ *
+ * await copyTextToClipboard('Hello, World!');
+ * console.log('Text copied to clipboard');
+ * ```
+ */
+export declare function copyTextToClipboard(data: string): Promise<void>;
+/**
+ * Copies a ClipboardItem (which can contain multiple formats) to the system clipboard.
+ *
+ * @param data - ClipboardItem containing the data to copy (supports multiple MIME types)
+ * @returns Promise that resolves when the data is copied
+ *
+ * @remarks
+ * Supports rich clipboard content including images, HTML, and text. Falls back to text-only
+ * copying if the Clipboard API is not available. The ClipboardItem can contain multiple
+ * representations (e.g., both text and HTML) and the system will use the most appropriate one.
+ *
+ * @example
+ * ```typescript
+ * import { copyToClipboard } from '..';
+ *
+ * // Copy text and HTML to clipboard
+ * const item = new ClipboardItem({
+ *   'text/plain': new Blob(['Hello'], { type: 'text/plain' }),
+ *   'text/html': new Blob(['<b>Hello</b>'], { type: 'text/html' })
+ * });
+ *
+ * await copyToClipboard(item);
+ * ```
+ */
+export declare function copyToClipboard(data: ClipboardItem): Promise<void>;
+export declare function isDarkTheme(): boolean;
+/**
+ * Detects if the Compute Pressure API (PressureObserver) is available in the current browser.
+ * Currently supported in Chrome, Edge, and Opera.
+ *
+ * @returns `true` if `PressureObserver` is available on `window`, `false` otherwise.
+ */
+export declare function isComputePressureSupported(): boolean;
+//# sourceMappingURL=browser.d.ts.map

package/lib/utils/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/utils/browser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAGvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,yBAA+C,CAAC;AAqBvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAKrC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAIlC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAInC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAIrC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAWjC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAmBjC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAG5E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,gCAAgC,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAG7F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,iBAGrD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,aAAa,iBAOxD;AAmBD,wBAAgB,WAAW,IAAI,OAAO,CAKrC;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD"}

package/lib/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./anonymizer";
+export * from "./stringifyError";
+export * from "./browser";
+export * from "./allSettled";
+export * from "./wait";
+export * from "./video";
+export * from "./recordingArchiveName";
+export * from "./serverTimestamp";
+export { default as xmlParser } from "./xmlParser";
+export type { XMLElement } from "./xmlParser";
+export * from "./xmlValidation";
+//# sourceMappingURL=index.d.ts.map

package/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,cAAc,iBAAiB,CAAC"}

package/lib/utils/mediaPermissionError.d.ts

@@ -0,0 +1,2 @@
+export declare function isMediaPermissionDeniedError(error: unknown): error is DOMException;
+//# sourceMappingURL=mediaPermissionError.d.ts.map

package/lib/utils/mediaPermissionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaPermissionError.d.ts","sourceRoot":"","sources":["../../src/utils/mediaPermissionError.ts"],"names":[],"mappings":"AAAA,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAKlF"}

package/lib/utils/promiseQueue.d.ts

@@ -0,0 +1,10 @@
+export declare class PromiseQueue {
+    private queue;
+    private started;
+    private logger;
+    static create(): PromiseQueue;
+    add(promise: () => Promise<any>): void;
+    private execute;
+    private timeoutPromise;
+}
+//# sourceMappingURL=promiseQueue.d.ts.map

package/lib/utils/promiseQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promiseQueue.d.ts","sourceRoot":"","sources":["../../src/utils/promiseQueue.ts"],"names":[],"mappings":"AAGA,qBAAa,YAAY;IACrB,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,MAAM,CAA8C;WAE9C,MAAM;IAEb,GAAG,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC;IAKtC,OAAO,CAAC,OAAO;IAqBf,OAAO,CAAC,cAAc;CAUzB"}

package/lib/utils/randomString.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (length?: number) => string;
+export default _default;
+//# sourceMappingURL=randomString.d.ts.map

package/lib/utils/randomString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomString.d.ts","sourceRoot":"","sources":["../../src/utils/randomString.ts"],"names":[],"mappings":"yBAAgB,SAAQ,MAAW,KAAG,MAAM;AAA5C,wBAME"}

package/lib/utils/recordingArchiveName.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Default name of the archive downloaded for a recording (conference or P2P recap).
+ *
+ * The date parts are taken in local time so the name matches what the user sees in the UI.
+ * Minutes are part of the name because two recordings of the same day would otherwise collide
+ * and the browser would silently suffix the second one with " (1)".
+ *
+ * `new Date()` never throws on a malformed input -- it returns an invalid date whose getters all
+ * yield NaN -- so the invalid case is tested explicitly and falls back to the raw start date,
+ * stripped of the characters that are not allowed in a file name.
+ */
+export declare function buildRecordingArchiveName(startDate?: string): string;
+//# sourceMappingURL=recordingArchiveName.d.ts.map

package/lib/utils/recordingArchiveName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordingArchiveName.d.ts","sourceRoot":"","sources":["../../src/utils/recordingArchiveName.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAMpE"}

package/lib/utils/serverTimestamp.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The server identifies a stored message by the pair (msg_id, msg_ts), where msg_ts is the
+ * microsecond epoch it assigned when it persisted the message. A reaction stanza has to echo
+ * that exact value back, so the client must keep the server's microseconds verbatim.
+ *
+ * `new Date(iso).getTime()` only yields milliseconds, so the last three digits would be lost
+ * and rebuilding them as `${ms}000` would produce a value the server cannot match. This reads
+ * the fractional-seconds digits straight from the ISO string instead, and right-pads them to
+ * six so `2026-09-20T09:21:20.095441Z` gives "1789896080095441".
+ *
+ * Returns null when the input is missing or not a valid date -- callers then fall back to
+ * whatever timestamp they already have.
+ */
+export declare function isoToMicros(iso: string | undefined | null): string | null;
+//# sourceMappingURL=serverTimestamp.d.ts.map

package/lib/utils/serverTimestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverTimestamp.d.ts","sourceRoot":"","sources":["../../src/utils/serverTimestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAQzE"}

package/lib/utils/stringifyError.d.ts

@@ -0,0 +1,2 @@
+export declare function stringifyError(error: unknown): string;
+//# sourceMappingURL=stringifyError.d.ts.map

package/lib/utils/stringifyError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyError.d.ts","sourceRoot":"","sources":["../../src/utils/stringifyError.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQrD"}

package/lib/utils/video.d.ts

@@ -0,0 +1,27 @@
+/**
+ * {@link extractNonBlackFrame} tuning options
+ */
+interface NonBlackFrameOption {
+    /** How often to check for a valid frame, in milliseconds. Defaults to `200`. */
+    intervalMs?: number;
+    /** Maximum time to wait before rejecting, in milliseconds. Defaults to `5000`. */
+    timeoutMs?: number;
+    /** Minimum per-channel value (0-255) to consider a pixel bright. Defaults to `20`. */
+    brightnessThreshold?: number;
+    /** Minimum ratio of bright pixels required to accept the frame. Defaults to `0.02`. */
+    minBrightPixelRatio?: number;
+}
+/**
+ * Extracts the first non-black frame from a {@link MediaStream} as a JPEG data URL.
+ *
+ * Polls the stream at regular intervals until a frame with enough visible
+ * pixels is found, then returns it as a JPEG data URL.
+ *
+ * @param stream - The {@link MediaStream} containing a video track.
+ * @param options - Optional tuning parameters.
+ * @returns A promise that resolves with a JPEG data URL of the first non-black frame found.
+ * @throws If no non-black frame is found within `timeoutMs`.
+ */
+export declare function extractNonBlackFrame(stream: MediaStream, options?: Partial<NonBlackFrameOption>): Promise<string>;
+export {};
+//# sourceMappingURL=video.d.ts.map

package/lib/utils/video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../src/utils/video.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,UAAU,mBAAmB;IACzB,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sFAAsF;IACtF,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uFAAuF;IACvF,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAC3C,OAAO,CAAC,MAAM,CAAC,CAuDjB"}

package/lib/utils/wait.d.ts

@@ -0,0 +1,2 @@
+export declare function wait(milliseconds: number): Promise<void>;
+//# sourceMappingURL=wait.d.ts.map

package/lib/utils/wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../src/utils/wait.ts"],"names":[],"mappings":"AAAA,wBAAgB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExD"}

package/lib/utils/xmlParser.d.ts

@@ -0,0 +1,102 @@
+export declare class XMLElement {
+    elem: Element;
+    constructor(elem: Element);
+    /**
+     * Reads a single attribute, `null` if not set.
+     * @param name - attribute name.
+     */
+    attr(name: string): string | null;
+    /**
+     * Reads several attributes at once.
+     * @param names - attribute names to read.
+     */
+    attrs<K extends string>(names: readonly K[]): Record<K, string | null>;
+    /** The element's text content. */
+    text(): string;
+    /** The element's tag name. */
+    get tagName(): string;
+    /** The element's direct children, wrapped. */
+    children(): XMLElements;
+    /**
+     * CSS-selector query for descendants, wrapped.
+     *
+     * Supports jQuery-style `>child` direct-child shorthand and namespaced `[xmlns=...]` attribute selectors.
+     * @param selector - CSS selector.
+     */
+    find(selector: string): XMLElements;
+}
+export declare class XMLElements {
+    elems: XMLElement[];
+    constructor(elems: XMLElement[]);
+    /**
+     * Runs `callbackfn` over each element in the list.
+     * @param callbackfn - called with each element, its index, and the backing array.
+     */
+    forEach(callbackfn: (value: XMLElement, index: number, array: XMLElement[]) => void): void;
+    /**
+     * Forward the array iterator, which allow to do this
+     *
+     * ```ts
+     * const parent: XMLElement = getParent()
+     * const elements: XMLElements = parent.children()
+     * for (const element of elements) {
+     *   // do things
+     * }
+     * ```
+     *
+     * The method behave the same way as `forEach`. Here is the equivalent:
+     * ```ts
+     * const parent: XMLElement = getParent()
+     * const elements: XMLElements = parent.children()
+     * elements.forEach((element) => {
+     *   // do things
+     * })
+     * ```
+     *
+     * The main advantage of using an iterator is that we can use promise and async/await with
+     * it nativelly, where the `forEach` can't without causing side-effects.
+     *
+     * Here is the [Iterator documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_generators)
+     * @returns iterator over the wrapped elements.
+     */
+    [Symbol.iterator](): ArrayIterator<XMLElement>;
+    /**
+     * `true` if `callbackfn` returns truthy for at least one element.
+     * @param callbackfn - called with each element, its index, and the backing array.
+     */
+    some(callbackfn: (value: XMLElement, index: number, array: XMLElement[]) => unknown): boolean;
+    /**
+     * Maps each element through `callbackfn`.
+     * @param callbackfn - called with each element, its index, and the backing array.
+     */
+    map<T>(callbackfn: (value: XMLElement, index: number, array: XMLElement[]) => T): T[];
+    /**
+     * Retrieve an attribute on the first element of the list
+     * @param name - attribute name.
+     */
+    attr(name: string): string | null;
+    /**
+     * Reads several attributes at once.
+     * @param names - attribute names to read.
+     */
+    attrs<K extends string>(names: readonly K[]): Record<K, string | null>;
+    /** Text content of the first element of the list, `null` if empty. */
+    text(): string | null;
+    /**
+     * CSS-selector query for descendants of the first element of the list, empty result if the list itself is empty.
+     * @param selector - CSS selector.
+     */
+    find(selector: string): XMLElements;
+    /** The first element of the list, `null` if empty. */
+    first(): XMLElement | null;
+    /** Number of elements in the list. */
+    get length(): number;
+}
+/**
+ * Wraps an existing `Element` as-is, or parses `element` as `ns`-typed markup and wraps its document element.
+ * @param element - existing `Element`, or markup string to parse.
+ * @param ns - MIME type used to parse `element` when it's a string. Defaults to `"application/xml"`.
+ */
+declare const _default: (element: string | Element, ns?: DOMParserSupportedType) => XMLElement;
+export default _default;
+//# sourceMappingURL=xmlParser.d.ts.map

package/lib/utils/xmlParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xmlParser.d.ts","sourceRoot":"","sources":["../../src/utils/xmlParser.ts"],"names":[],"mappings":"AAyBA,qBAAa,UAAU;IACO,IAAI,EAAE,OAAO;gBAAb,IAAI,EAAE,OAAO;IAEvC;;;OAGG;IACI,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIxC;;;OAGG;IACI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAI7E,kCAAkC;IAC3B,IAAI,IAAI,MAAM;IAIrB,8BAA8B;IAC9B,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,8CAA8C;IACvC,QAAQ,IAAI,WAAW;IAI9B;;;;;OAKG;IACI,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW;CAI7C;AAED,qBAAa,WAAW;IACM,KAAK,EAAE,UAAU,EAAE;gBAAnB,KAAK,EAAE,UAAU,EAAE;IAE7C;;;OAGG;IACI,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,IAAI,GAAG,IAAI;IAEjG;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIxB;;;OAGG;IACI,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,OAAO,GAAG,OAAO;IAIpG;;;OAGG;IACI,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE;IAI5F;;;OAGG;IACI,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIxC;;;OAGG;IACI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAI7E,sEAAsE;IAC/D,IAAI,IAAI,MAAM,GAAG,IAAI;IAI5B;;;OAGG;IACI,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW;IAI1C,sDAAsD;IAC/C,KAAK,IAAI,UAAU,GAAG,IAAI;IAIjC,sCAAsC;IACtC,IAAW,MAAM,IAAI,MAAM,CAE1B;CACJ;AAED;;;;GAIG;yBACa,SAAS,MAAM,GAAG,OAAO,EAAE,KAAI,sBAA0C,KAAG,UAAU;AAAtG,wBAKE"}

package/lib/utils/xmlValidation.d.ts

@@ -0,0 +1,119 @@
+import * as v from "valibot";
+import { XMLElement } from "./xmlParser";
+/**
+ * Declarative shape passed to {@link xmlElement}.
+ *
+ * @public
+ */
+interface XmlElementShape {
+    /**
+     * Restricts this schema to elements with this exact tag name; parsing throws otherwise.
+     *
+     * @remarks
+     * The tag is echoed in the output as a literal, so a `v.union([...])` of tagged schemas forms a
+     * discriminated union -- narrow on `result.tag` before reading `result.attrs`.
+     */
+    tag?: string;
+    /**
+     * Schema per attribute name, applied to `elem.attr(name)`.
+     *
+     * @remarks
+     * A missing attribute reads as `undefined` (not `null`), so `v.optional(schema, fallback)` gives
+     * it a default. That fallback is an *input* run through `schema`: with a coercing schema such as
+     * `v.pipe(v.string(), v.toNumber())` it must be `'0'`, not `0`.
+     */
+    attrs?: Record<string, v.GenericSchema<string | undefined, unknown>>;
+    /**
+     * Schema applied to `elem.text()`.
+     */
+    text?: v.GenericSchema;
+    /**
+     * Schema per child, keyed by CSS selector.
+     *
+     * @remarks
+     * Keys are resolved via `elem.find(key)`: a bare tag name matches any descendant, `> tag`
+     * restricts to direct children, deeper paths such as `> parent > child` match at any depth.
+     * A bare schema requires exactly one match, `v.optional(schema)` allows none, `v.array(schema)`
+     * takes all. Cardinality is read from the spec's own `type`, so those wrappers stay outermost:
+     * `v.array(v.lazy(() => self))`, never the reverse, which silently matches a single element.
+     */
+    children?: Record<string, ChildSpec>;
+}
+type ChildSpec = v.GenericSchema | v.OptionalSchema<v.GenericSchema, undefined> | v.ArraySchema<v.GenericSchema, undefined>;
+type AttrsOutput<T extends XmlElementShape> = T["attrs"] extends Record<string, v.GenericSchema<string | undefined, unknown>> ? {
+    [K in keyof T["attrs"]]: v.InferOutput<T["attrs"][K]>;
+} : Record<never, never>;
+type ChildOutput<S extends ChildSpec> = S extends v.ArraySchema<infer Item extends v.GenericSchema, undefined> ? v.InferOutput<Item>[] : S extends v.OptionalSchema<infer Wrapped extends v.GenericSchema, undefined> ? v.InferOutput<Wrapped> | undefined : S extends v.GenericSchema ? v.InferOutput<S> : never;
+type ChildrenOutput<T extends XmlElementShape> = T["children"] extends Record<string, ChildSpec> ? {
+    [K in keyof T["children"]]: ChildOutput<T["children"][K]>;
+} : Record<never, never>;
+interface TextOutput<T extends XmlElementShape> {
+    text: T["text"] extends v.GenericSchema ? v.InferOutput<T["text"]> : undefined;
+}
+interface TagOutput<T extends XmlElementShape> {
+    tag: T["tag"] extends string ? T["tag"] : undefined;
+}
+/**
+ * Precise output type of the schema produced by {@link xmlElement} for a given shape `T`.
+ *
+ * @public
+ */
+export type XmlElementOutput<T extends XmlElementShape> = {
+    elem: XMLElement;
+    attrs: AttrsOutput<T>;
+} & TextOutput<T> & TagOutput<T> & ChildrenOutput<T>;
+/**
+ * Output of a self-recursive {@link xmlElement} schema: the element `T`, whose child selector `K`
+ * holds an array of that same element.
+ *
+ * @public
+ */
+export type XmlElementRecursiveOutput<T extends XmlElementShape, K extends string> = XmlElementOutput<T> & {
+    [P in K]: XmlElementRecursiveOutput<T, K>[];
+};
+/**
+ * Annotation for a self-recursive {@link xmlElement} schema, which TypeScript cannot infer.
+ *
+ * @example
+ * ```ts
+ * const base = xmlElement({ attrs: { label: v.string() } })
+ * const node: XmlElementRecursiveSchema<typeof base.shape, "> node"> = xmlElement({
+ *   ...base.shape,
+ *   children: { "> node": v.array(v.lazy(() => node)) },
+ * })
+ * ```
+ *
+ * @public
+ */
+export type XmlElementRecursiveSchema<T extends XmlElementShape, K extends string> = v.GenericSchema<XMLElement, XmlElementRecursiveOutput<T, K>>;
+/**
+ * Builds a valibot schema that validates an {@link XMLElement}.
+ *
+ * @remarks
+ * The result always carries `elem`, so callers can fall back to manual `find`/`attr`/`text` for
+ * anything the shape does not declare. The returned `shape` is the counterpart of `entries` on a
+ * valibot object schema, making an existing element extensible as
+ * `xmlElement({ ...stanza.shape, tag: "message" })` -- a shallow spread, so `attrs` and `children`
+ * are replaced rather than merged.
+ *
+ * @example
+ * ```ts
+ * const book = xmlElement({
+ *   attrs: { id: v.string() },
+ *   text: v.string(),
+ *   children: { author: v.optional(xmlElement({ text: v.string() })) },
+ * })
+ * const result = v.parse(book, elem)
+ * ```
+ *
+ * @param shape - Schema definition for tag, attrs, text and children.
+ * @returns A schema accepting an `XMLElement`, carrying the `shape` it was built from.
+ *
+ * @public
+ */
+export declare function xmlElement<const T extends XmlElementShape>(shape: T): v.GenericSchema<XMLElement, XmlElementOutput<T>> & {
+    shape: T;
+};
+export type InferXmlElement<T extends v.GenericSchema> = v.InferOutput<T>;
+export {};
+//# sourceMappingURL=xmlValidation.d.ts.map

package/lib/utils/xmlValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xmlValidation.d.ts","sourceRoot":"","sources":["../../src/utils/xmlValidation.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@ale-rainbow/web-sdk",
+  "type": "module",
+  "version": "5.1.0",
+  "description": "",
+  "author": "",
+  "license": "ISC",
+  "sideEffects": [
+    "./src/libs/strophe/**/*.js",
+    "./src/strophejs.ts",
+    "./src/libs/strophe/strophe.rsm.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js"
+    },
+    "./node": {
+      "types": "./lib/node.d.ts",
+      "import": "./lib/node.js",
+      "require": "./lib/node.js"
+    },
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js"
+    }
+  },
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "umd": "lib/index.umd.js",
+  "types": "lib/",
+  "files": [
+    "/lib/**"
+  ],
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "canvas": "^3.2.3",
+    "crypto-es": "^3.1.3",
+    "date-fns": "^4.4.0",
+    "flatted": "^3.4.2",
+    "jquery": "^3.7.1",
+    "jsdom": "^29.0.2",
+    "jwt-decode": "^4.0.0",
+    "lodash-es": "^4.18.1",
+    "node-localstorage": "^3.0.5",
+    "rxjs": "7.8.2",
+    "sanitize-html": "^2.17.3",
+    "strophe.js": "^3.1.1",
+    "ts-ebml": "^2.0.2",
+    "uuid": "14.0.0",
+    "valibot": "^1.3.1",
+    "webrtc-adapter": "7.5.1",
+    "ws": "^8.20.0",
+    "xml-rpc-ts": "^1.0.2"
+  }
+}