@kosdev-code/kos-ui-sdk 2.0.24 → 2.0.26

package/models/models/canvas-dispatcher/canvas-dispatcher-model.d.ts

@@ -0,0 +1,29 @@
+import { CanvasDispatcherOptions, RenderDataSpecification, Renderer } from './types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+
+export declare const MODEL_TYPE = "canvas-dispatcher-model";
+export type CanvasDispatcherModel = PublicModelInterface<CanvasDispatcherModelImpl>;
+export declare class CanvasDispatcherModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    private router;
+    pattern?: string;
+    data?: RenderDataSpecification<any> | null;
+    active: boolean;
+    constructor(modelId: string, options: CanvasDispatcherOptions, context: KosCreationContext);
+    get renderer(): Renderer | null;
+    /**
+     * Sends a data frame to the canvas dispatcher.
+     *
+     * @param data - The data frame to be sent as a string.
+     *
+     * @remarks
+     * This method is responsible for dispatching the provided data frame
+     * to the canvas system using the `sendCanvasData` function.
+     */
+    sendDataFrame(data: string): void;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=canvas-dispatcher-model.d.ts.map

package/models/models/canvas-dispatcher/canvas-dispatcher-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-dispatcher-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/canvas-dispatcher-model.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EACV,uBAAuB,EAEvB,uBAAuB,EACvB,QAAQ,EACT,MAAM,SAAS,CAAC;AAGjB,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAEpD,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAElD,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAKjC,OAAO,CAAC,MAAM,CAAoB;IAElC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,uBAAuB,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAE3C,MAAM,UAAS;gBAEb,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAU7B,IAAI,QAAQ,IAAI,QAAQ,GAAG,IAAI,CAW9B;IACD;;;;;;;;OAQG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CA2B5B"}

package/models/models/canvas-dispatcher/canvas-dispatcher-registration.d.ts

@@ -0,0 +1,89 @@
+import { CanvasDispatcherOptions } from './types';
+import { CanvasDispatcherModel } from './canvas-dispatcher-model';
+import { SingletonKosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # CanvasDispatcher
+ *
+ * The registration bean includes convenience methods for creating and working with CanvasDispatcherModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: CanvasDispatcher.type, id: "canvasDispatcherId"})
+ * private canvasDispatcherModel: CanvasDispatcherModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new CanvasDispatcherModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = CanvasDispatcher.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a CanvasDispatcherModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (CanvasDispatcher.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to CanvasDispatcherModel
+ *    // and the compiler will know that the model has the CanvasDispatcherModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { CanvasDispatcher } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(CanvasDispatcher);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The canvasDispatcher model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const CanvasDispatcher: SingletonKosModelRegistrationFactory<CanvasDispatcherModel, CanvasDispatcherOptions>;
+//# sourceMappingURL=canvas-dispatcher-registration.d.ts.map

package/models/models/canvas-dispatcher/canvas-dispatcher-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-dispatcher-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/canvas-dispatcher-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAKvE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,gBAAgB,sFAM3B,CAAC"}

package/models/models/canvas-dispatcher/index.d.ts

@@ -0,0 +1,5 @@
+export { CanvasDispatcher } from './canvas-dispatcher-registration';
+export type * from './types';
+export type { CanvasDispatcherModel } from './canvas-dispatcher-model';
+export * as CanvasDispatcherServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/canvas-dispatcher/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,wBAAwB,MAAM,YAAY,CAAC"}

package/models/models/canvas-dispatcher/services/canvas-dispatcher-services.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sends canvas data to a specified endpoint using a POST request.
+ *
+ * @param data - The data to be sent to the canvas endpoint.
+ * @returns A promise that resolves when the data has been successfully sent.
+ */
+export declare const sendCanvasData: (data: any) => Promise<void>;
+//# sourceMappingURL=canvas-dispatcher-services.d.ts.map

package/models/models/canvas-dispatcher/services/canvas-dispatcher-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-dispatcher-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/services/canvas-dispatcher-services.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,SAAgB,GAAG,kBAW7C,CAAC"}

package/models/models/canvas-dispatcher/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './canvas-dispatcher-services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/canvas-dispatcher/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}

package/models/models/canvas-dispatcher/types/index.d.ts

@@ -0,0 +1,55 @@
+export interface CanvasDispatcherOptions {}
+declare interface Renderer {
+  reset(): void;
+  renderFrame(width: number, height: number): void | Uint8ClampedArray;
+  readPixels(width: number, height: number): Uint8ClampedArray;
+  play?(): void;
+  pause?(): void;
+}
+
+declare interface DoneAware {
+  onDone(cb: () => void): void;
+  isOneShot?: () => boolean; // optional flag
+}
+
+declare interface OneShotCapable extends DoneAware {
+  resetOneShot(): void;
+  signalDoneIfNeeded(): void;
+  readonly isOneShotDone: boolean;
+}
+
+declare type RendererOptions = "sweep" | "matrix" | "video" | "drop" | "none";
+
+declare interface RenderSpecification<T extends string> {
+  type: T;
+  id: string;
+  data: RenderDataSpecification<T>;
+}
+
+declare interface SourceRenderDataSpecification {
+  src: string;
+}
+
+declare interface ColorRenderDataSpecification {
+  color: string;
+}
+
+declare type RenderDataSpecification<T extends string> = T extends "video"
+  ? SourceRenderDataSpecification
+  : T extends "image"
+  ? SourceRenderDataSpecification
+  : T extends "color"
+  ? ColorRenderDataSpecification
+  : Record<string, any>;
+
+declare type VideoRenderData = RenderSpecification<"video">;
+
+declare type ImageRenderData = RenderSpecification<"image">;
+
+declare type ColorRenderData = RenderSpecification<"color">;
+
+declare type RenderData =
+  | VideoRenderData
+  | ImageRenderData
+  | ColorRenderData
+  | RenderSpecification<"none">;

package/models/models/canvas-dispatcher/utils/renderers/base/canvas-2d-renderer.d.ts

@@ -0,0 +1,36 @@
+import { Renderer } from '../../../types';
+
+/**
+ * An abstract base class for 2D canvas rendering. This class provides a foundational
+ * implementation for managing a canvas element and its 2D rendering context, as well
+ * as utility methods for rendering and pixel data extraction.
+ *
+ * Subclasses must implement the `reset` and `renderFrame` methods to define specific
+ * rendering behavior.
+ *
+ * @implements Renderer
+ */
+export declare abstract class Canvas2DRendererBase implements Renderer {
+    protected canvas: HTMLCanvasElement;
+    protected ctx: CanvasRenderingContext2D;
+    protected lastUpdate: number;
+    constructor();
+    /**
+     * Determines whether a specified time interval has elapsed since the last update.
+     *
+     * @param intervalMs - The time interval in milliseconds to check against.
+     * @returns `true` if the elapsed time since the last update is greater than or equal to the specified interval; otherwise, `false`.
+     */
+    protected shouldStep(intervalMs: number): boolean;
+    abstract reset(): void;
+    abstract renderFrame(width: number, height: number): void;
+    /**
+     * Reads pixel data from the canvas context within the specified width and height.
+     *
+     * @param width - The width of the area to read pixels from, starting at the top-left corner (0, 0).
+     * @param height - The height of the area to read pixels from, starting at the top-left corner (0, 0).
+     * @returns A `Uint8ClampedArray` containing the RGBA pixel data for the specified area.
+     */
+    readPixels(width: number, height: number): Uint8ClampedArray;
+}
+//# sourceMappingURL=canvas-2d-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/base/canvas-2d-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-2d-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/base/canvas-2d-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;GASG;AACH,8BAAsB,oBAAqB,YAAW,QAAQ;IAC5D,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACpC,SAAS,CAAC,GAAG,EAAE,wBAAwB,CAAC;IACxC,SAAS,CAAC,UAAU,SAAK;;IASzB;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAQjD,QAAQ,CAAC,KAAK,IAAI,IAAI;IACtB,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAEzD;;;;;;OAMG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB;CAG7D"}

package/models/models/canvas-dispatcher/utils/renderers/base/gradient-base-renderer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gradient-base-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/base/gradient-base-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient-base-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/base/gradient-base-renderer.ts"],"names":[],"mappings":""}

package/models/models/canvas-dispatcher/utils/renderers/base/video-base-renderer.d.ts

@@ -0,0 +1,67 @@
+import { DoneAware, Renderer } from '../../../types';
+
+/**
+ * A base class for rendering video frames using a 2D canvas.
+ *
+ * Provides utilities for frame capture, playback control, and detecting when a video has finished playing.
+ * Implements the `Renderer` and `DoneAware` interfaces to integrate with a unified animation/rendering system.
+ */
+export declare class VideoRendererBase implements Renderer, DoneAware {
+    /** The underlying HTML video element used as the media source */
+    protected video: HTMLVideoElement;
+    /** Internal offscreen canvas used to draw current video frame */
+    protected canvas: HTMLCanvasElement;
+    /** 2D rendering context for the offscreen canvas */
+    protected ctx: CanvasRenderingContext2D;
+    /** Timestamp of the last update (used for throttling if needed) */
+    protected lastUpdate: number;
+    /** Callback to invoke when video playback completes */
+    private doneCallback;
+    /**
+     * Constructs a video renderer that will play and extract pixels from the provided source.
+     *
+     * @param src - The URL or path of the video to play
+     */
+    constructor(src: string);
+    /**
+     * Resets the video to the beginning and pauses playback.
+     */
+    reset(): void;
+    /**
+     * Starts or resumes playback of the video.
+     */
+    play(): void;
+    /**
+     * Pauses video playback.
+     */
+    pause(): void;
+    /**
+     * Draws the current video frame onto the offscreen canvas at the given resolution.
+     *
+     * @param width - Desired canvas width
+     * @param height - Desired canvas height
+     */
+    renderFrame(width: number, height: number): void;
+    /**
+     * Extracts the most recently rendered frame's pixel data as a flat RGBA array.
+     *
+     * @param width - Width of the canvas area to extract
+     * @param height - Height of the canvas area to extract
+     * @returns A Uint8ClampedArray containing RGBA values
+     */
+    readPixels(width: number, height: number): Uint8ClampedArray;
+    /**
+     * Registers a callback to be invoked once the video finishes playing.
+     *
+     * @param callback - Function to call on video end
+     */
+    onDone(callback: () => void): void;
+    /**
+     * Utility method for timing-based frame updates (optional use).
+     *
+     * @param intervalMs - Minimum time between steps in milliseconds
+     * @returns `true` if enough time has passed to trigger a new update
+     */
+    protected shouldStep(intervalMs: number): boolean;
+}
+//# sourceMappingURL=video-base-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/base/video-base-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-base-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/base/video-base-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1D;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,QAAQ,EAAE,SAAS;IAC3D,iEAAiE;IACjE,SAAS,CAAC,KAAK,EAAE,gBAAgB,CAAC;IAElC,iEAAiE;IACjE,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAEpC,oDAAoD;IACpD,SAAS,CAAC,GAAG,EAAE,wBAAwB,CAAC;IAExC,mEAAmE;IACnE,SAAS,CAAC,UAAU,SAAK;IAEzB,uDAAuD;IACvD,OAAO,CAAC,YAAY,CAA6B;IAEjD;;;;OAIG;gBACS,GAAG,EAAE,MAAM;IAkBvB;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAShD;;;;;;OAMG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB;IAI5D;;;;OAIG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAIlC;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;CAQlD"}

package/models/models/canvas-dispatcher/utils/renderers/base/webgl-base-renderer.d.ts

@@ -0,0 +1,51 @@
+import { Renderer } from '../../../types';
+
+/**
+ * Abstract base class for WebGL-based renderers.
+ *
+ * Provides a shared WebGL canvas, rendering context, and utility methods for
+ * consistent pixel reading and throttled animation timing.
+ */
+export declare abstract class WebGLRendererBase implements Renderer {
+    /** The internal offscreen canvas used for rendering */
+    protected canvas: HTMLCanvasElement;
+    /** The WebGL rendering context used to draw and sample frames */
+    protected gl: WebGLRenderingContext;
+    /** The last known canvas width used for reading pixels */
+    protected lastWidth: number;
+    /** The last known canvas height used for reading pixels */
+    protected lastHeight: number;
+    /** Timestamp of the last frame update used for throttling */
+    protected lastUpdate: number;
+    constructor();
+    /**
+     * Reset the internal renderer state.
+     * Must be implemented by subclasses to reset animation state.
+     */
+    abstract reset(): void;
+    /**
+     * Render a frame at the given resolution into the internal WebGL canvas.
+     * This method should perform the draw but not return the pixels.
+     *
+     * @param width - The width of the canvas to render to
+     * @param height - The height of the canvas to render to
+     */
+    abstract renderFrame(width: number, height: number): void;
+    /**
+     * Throttle rendering logic based on a minimum time interval.
+     *
+     * @param intervalMs - The minimum time in milliseconds between steps
+     * @returns `true` if enough time has passed to perform a new step
+     */
+    protected shouldStep(intervalMs: number): boolean;
+    /**
+     * Read and return the current pixel buffer from the WebGL canvas.
+     * The result is vertically flipped to match 2D canvas expectations.
+     *
+     * @param width - Optional override for width (defaults to `lastWidth`)
+     * @param height - Optional override for height (defaults to `lastHeight`)
+     * @returns A `Uint8ClampedArray` of RGBA pixel data
+     */
+    readPixels(width?: number, height?: number): Uint8ClampedArray;
+}
+//# sourceMappingURL=webgl-base-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/base/webgl-base-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-base-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/base/webgl-base-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;GAKG;AACH,8BAAsB,iBAAkB,YAAW,QAAQ;IACzD,uDAAuD;IACvD,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAEpC,iEAAiE;IACjE,SAAS,CAAC,EAAE,EAAE,qBAAqB,CAAC;IAEpC,0DAA0D;IAC1D,SAAS,CAAC,SAAS,SAAK;IAExB,2DAA2D;IAC3D,SAAS,CAAC,UAAU,SAAK;IAEzB,6DAA6D;IAC7D,SAAS,CAAC,UAAU,SAAK;;IASzB;;;OAGG;IACH,QAAQ,CAAC,KAAK,IAAI,IAAI;IAEtB;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAEzD;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IASjD;;;;;;;OAOG;IACH,UAAU,CACR,KAAK,SAAiB,EACtB,MAAM,SAAkB,GACvB,iBAAiB;CAsBrB"}

package/models/models/canvas-dispatcher/utils/renderers/drop-renderer.d.ts

@@ -0,0 +1,58 @@
+import { WebGLRendererBase } from './base/webgl-base-renderer';
+import { Renderer } from '../../types';
+
+/**
+ * A WebGL-based renderer that creates a vertical color-drop animation.
+ *
+ * This renderer simulates falling color bands (like a waterfall or rain)
+ * by animating a vertical gradient of hues within a specified hue range.
+ *
+ * The animation is driven by a shader program and controlled through
+ * uniform parameters including `hueOffset`, `minHue`, and `maxHue`.
+ */
+export declare class DropRenderer extends WebGLRendererBase implements Renderer {
+    private program;
+    private posBuffer;
+    private aPosition;
+    private uMinHue;
+    private uMaxHue;
+    private uHueOffset;
+    private uGridHeight;
+    private minHue;
+    private maxHue;
+    private hueOffset;
+    private speedPx;
+    /**
+     * Creates a new DropRenderer with the specified scroll speed.
+     * @param speedPx - The vertical speed in pixels per update cycle.
+     */
+    constructor(speedPx?: number);
+    /**
+     * Resets the renderer's animation state to its initial values.
+     */
+    reset(): void;
+    /**
+     * Renders a new frame by updating hueOffset and redrawing the gradient.
+     *
+     * @param width - Width of the output frame
+     * @param height - Height of the output frame
+     */
+    renderFrame(width: number, height: number): void;
+    /**
+     * Compiles a GLSL shader of the given type.
+     *
+     * @param type - gl.VERTEX_SHADER or gl.FRAGMENT_SHADER
+     * @param source - GLSL source code
+     * @returns The compiled shader object
+     */
+    private compileShader;
+    /**
+     * Links a vertex and fragment shader into a complete WebGL program.
+     *
+     * @param vertexShader - Compiled vertex shader
+     * @param fragmentShader - Compiled fragment shader
+     * @returns The linked WebGL program
+     */
+    private createProgram;
+}
+//# sourceMappingURL=drop-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/drop-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/drop-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,iBAAkB,YAAW,QAAQ;IAErE,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,WAAW,CAAuB;IAG1C,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,OAAO,CAAK;IAEpB;;;OAGG;gBACS,OAAO,SAAI;IAwEvB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IA6BhD;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAYrB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;CAatB"}

package/models/models/canvas-dispatcher/utils/renderers/gradient-renderer.d.ts

@@ -0,0 +1,17 @@
+import { Canvas2DRendererBase } from './base/canvas-2d-renderer';
+import { OneShotCapable, Renderer } from '../../types';
+
+declare const GradientBase: import('./mixins/one-shot-renderer-mixin').AbstractConstructor<Canvas2DRendererBase & OneShotCapable>;
+export type GradientDirection = "horizontal" | "vertical" | "radial";
+export declare class GradientRenderer extends GradientBase implements Renderer, OneShotCapable {
+    private offset;
+    private speed;
+    private colors;
+    private direction;
+    private loop;
+    constructor(colors?: string[], direction?: GradientDirection, speed?: number, loop?: boolean);
+    reset(): void;
+    renderFrame(width: number, height: number): void;
+}
+export {};
+//# sourceMappingURL=gradient-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/gradient-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/gradient-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAGjE,QAAA,MAAM,YAAY,uGAA6C,CAAC;AAEhE,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,UAAU,GAAG,QAAQ,CAAC;AAErE,qBAAa,gBACX,SAAQ,YACR,YAAW,QAAQ,EAAE,cAAc;IAEnC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,IAAI,CAAU;gBAGpB,MAAM,GAAE,MAAM,EAA+B,EAC7C,SAAS,GAAE,iBAAgC,EAC3C,KAAK,SAAI,EACT,IAAI,UAAO;IASJ,KAAK,IAAI,IAAI;IAMb,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAyB1D"}

package/models/models/canvas-dispatcher/utils/renderers/image-renderer.d.ts

@@ -0,0 +1,13 @@
+import { Canvas2DRendererBase } from './base/canvas-2d-renderer';
+import { OneShotCapable, Renderer } from '../../types';
+
+declare const Base: import('./mixins/one-shot-renderer-mixin').AbstractConstructor<Canvas2DRendererBase & OneShotCapable>;
+export declare class ImageRenderer extends Base implements Renderer, OneShotCapable {
+    private img;
+    private loaded;
+    constructor(src: string);
+    reset(): void;
+    renderFrame(width: number, height: number): void;
+}
+export {};
+//# sourceMappingURL=image-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/image-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/image-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAGjE,QAAA,MAAM,IAAI,uGAA6C,CAAC;AAExD,qBAAa,aAAc,SAAQ,IAAK,YAAW,QAAQ,EAAE,cAAc;IACzE,OAAO,CAAC,GAAG,CAAmB;IAC9B,OAAO,CAAC,MAAM,CAAS;gBAEX,GAAG,EAAE,MAAM;IAYd,KAAK,IAAI,IAAI;IAKb,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAS1D"}

package/models/models/canvas-dispatcher/utils/renderers/matrix-renderer.d.ts

@@ -0,0 +1,36 @@
+import { Canvas2DRendererBase } from './base/canvas-2d-renderer';
+import { Renderer } from '../../types';
+
+/**
+ * A falling-character visual effect inspired by the Matrix.
+ *
+ * This renderer creates animated vertical columns of glowing characters that fall
+ * at different speeds and randomness, using a 2D canvas buffer.
+ */
+export declare class MatrixRenderer extends Canvas2DRendererBase implements Renderer {
+    /** Tracks the Y position of the falling highlight in each column */
+    private columns;
+    /** Probability that a column will advance during an update */
+    private fallChance;
+    /** Vertical step size (in pixels) for falling columns */
+    private speed;
+    /**
+     * Constructs a Matrix-style renderer.
+     *
+     * @param speed - How many pixels each column advances per update (default: 1)
+     * @param fallChance - Probability (0 to 1) that a column will fall on each frame (default: 0.7)
+     */
+    constructor(speed?: number, fallChance?: number);
+    /**
+     * Resets all column positions and timing state.
+     */
+    reset(): void;
+    /**
+     * Renders the next frame of the animation into the internal canvas buffer.
+     *
+     * @param width - Width of the canvas in pixels
+     * @param height - Height of the canvas in pixels
+     */
+    renderFrame(width: number, height: number): void;
+}
+//# sourceMappingURL=matrix-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/matrix-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/matrix-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,oBAAqB,YAAW,QAAQ;IAC1E,oEAAoE;IACpE,OAAO,CAAC,OAAO,CAAgB;IAE/B,8DAA8D;IAC9D,OAAO,CAAC,UAAU,CAAS;IAE3B,yDAAyD;IACzD,OAAO,CAAC,KAAK,CAAS;IAEtB;;;;;OAKG;gBACS,KAAK,SAAI,EAAE,UAAU,SAAM;IAMvC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAkDjD"}

package/models/models/canvas-dispatcher/utils/renderers/mixins/one-shot-renderer-mixin.d.ts

@@ -0,0 +1,5 @@
+import { OneShotCapable } from '../../../types';
+
+export type AbstractConstructor<T = any> = abstract new (...args: any[]) => T;
+export declare function OneShotRendererMixin<TBase extends AbstractConstructor>(Base: TBase): AbstractConstructor<InstanceType<TBase> & OneShotCapable>;
+//# sourceMappingURL=one-shot-renderer-mixin.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/mixins/one-shot-renderer-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"one-shot-renderer-mixin.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/mixins/one-shot-renderer-mixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,MAAM,mBAAmB,CAAC,CAAC,GAAG,GAAG,IAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAE9E,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,mBAAmB,EACpE,IAAI,EAAE,KAAK,GACV,mBAAmB,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,cAAc,CAAC,CAiC3D"}

package/models/models/canvas-dispatcher/utils/renderers/renderer-factory.d.ts

@@ -0,0 +1,30 @@
+import { RenderDataSpecification, Renderer } from '../../types';
+
+export declare const VIDEO_MAP: Record<string, {
+    url: string;
+    label: string;
+}>;
+export type VideoKeys = keyof typeof VIDEO_MAP;
+/**
+ * Returns a renderer instance based on the specified mode and parameters.
+ *
+ * @param params - An object containing the parameters for the renderer.
+ * @param params.mode - The mode of the renderer. Supported values are:
+ *   - `'matrix'`: Creates a matrix renderer with a specified fall chance.
+ *   - `'video'`: Creates a video renderer with a specified video source.
+ *   - `'image'`: Creates a image renderer with a specified inmage source.
+ *
+ * @param params.fallChance - The chance of falling, used only in `'matrix'` mode.
+ * @param params.video - The video source identifier, used only in `'video'` mode.
+ *   - `'video1'`: Uses the `/assets/video.mp4` file.
+ *   - Any other value: Uses the `/assets/circle-spin.mp4` file.
+ *
+ * @returns A `Renderer` instance corresponding to the specified mode.
+ *
+ * @throws {Error} If an unknown mode is provided.
+ */
+export declare const getRenderer: <T extends string>({ mode, data, }: {
+    mode: T;
+    data?: RenderDataSpecification<T> | null;
+}) => Renderer | null;
+//# sourceMappingURL=renderer-factory.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/renderer-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-factory.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/renderer-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,QAAQ,EAET,MAAM,aAAa,CAAC;AAOrB,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQ3D,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,SAAS,CAAC;AAC/C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,sCAGrB;IACD,IAAI,EAAE,CAAC,CAAC;IACR,IAAI,CAAC,EAAE,wBAAwB,CAAC,CAAC,GAAG,IAAI,CAAC;CAC1C,KAAG,QAAQ,GAAG,IAmBd,CAAC"}

package/models/models/canvas-dispatcher/utils/renderers/solid-color-renderer.d.ts

@@ -0,0 +1,17 @@
+import { Canvas2DRendererBase } from './base/canvas-2d-renderer';
+import { OneShotCapable, Renderer } from '../../types';
+
+declare const Base: import('./mixins/one-shot-renderer-mixin').AbstractConstructor<Canvas2DRendererBase & OneShotCapable>;
+/**
+ * Renders a single solid color frame onto the canvas.
+ * Implements OneShotCapable, signaling `onDone()` after the first render.
+ */
+export declare class SolidColorRenderer extends Base implements Renderer, OneShotCapable {
+    private color;
+    constructor(r?: number, g?: number, b?: number);
+    setColor(r: number, g: number, b: number): void;
+    reset(): void;
+    renderFrame(width: number, height: number): void;
+}
+export {};
+//# sourceMappingURL=solid-color-renderer.d.ts.map

package/models/models/canvas-dispatcher/utils/renderers/solid-color-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-color-renderer.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/canvas-dispatcher/utils/renderers/solid-color-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAGjE,QAAA,MAAM,IAAI,uGAA6C,CAAC;AAExD;;;GAGG;AACH,qBAAa,kBACX,SAAQ,IACR,YAAW,QAAQ,EAAE,cAAc;IAEnC,OAAO,CAAC,KAAK,CAAS;gBAEV,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI;IAK/B,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAKtC,KAAK,IAAI,IAAI;IAIb,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAW1D"}