@lappis/cg-manager 0.0.26 → 0.0.28

package/dist/layers.d.ts

@@ -1,66 +1,66 @@
-import { Effect } from './effect';
-import { BasicChannel, BasicLayer } from './basic';
-import { CommandExecutor } from './executor';
-export interface AllocateOptions {
-    count?: number;
-    index?: number;
-}
-export declare class EffectGroup {
-    effects: Effect[];
-    readonly name: string;
-    readonly channel: Channel;
-    constructor(channel: Channel, name: string);
-    addEffect(effect: Effect): void;
-    removeEffect(effect: Effect): void;
-    dispose(): void;
-    /** Gets the first index that is after all previous effects, and after all the effects layer. AKA the index for a new layer */
-    getEffectIndex(effect: Effect): number;
-    /** Gets the first index that is after all other effect groups */
-    protected getStartingIndex(): number;
-    toJSON(): {
-        name: string;
-        effects: string[];
-    };
-}
-export declare class Channel extends BasicChannel {
-    layers: Map<string, Layer>;
-    groups: EffectGroup[];
-    createGroup(name: string, index?: number): EffectGroup;
-    getGroup(name?: string, index?: number): EffectGroup;
-    private lastOrder;
-    private currentOrder;
-    executor: CommandExecutor;
-    constructor(casparChannel: number, executor?: CommandExecutor);
-    setExecutor(executor: CommandExecutor): void;
-    getLayer(id: string): Layer;
-    getLayers(): Layer[];
-    getLayerIndex(layer: Layer): number;
-    allocateLayers(options?: AllocateOptions): Layer[];
-    private needExecute;
-    allocateLayer(index?: number): Layer;
-    deallocateLayers(layers: Layer[]): void;
-    executeAllocation(): void;
-    toJSON(): {
-        channel: number;
-        layers: {
-            id: string;
-            effect: string;
-        }[];
-        groups: {
-            name: string;
-            effects: string[];
-        }[];
-    };
-}
-export declare class Layer extends BasicLayer {
-    readonly id: string;
-    constructor(channel: Channel);
-    private effect;
-    setEffect(effect: Effect): void;
-    getEffect(): Effect;
-    dispose(): void;
-    toJSON(): {
-        id: string;
-        effect: string;
-    };
-}
+import { Effect } from './effect';
+import { BasicChannel, BasicLayer } from './basic';
+import { CommandExecutor } from './executor';
+export interface AllocateOptions {
+    count?: number;
+    index?: number;
+}
+export declare class EffectGroup {
+    effects: Effect[];
+    readonly name: string;
+    readonly channel: Channel;
+    constructor(channel: Channel, name: string);
+    addEffect(effect: Effect): void;
+    removeEffect(effect: Effect): void;
+    dispose(): void;
+    /** Gets the first index that is after all previous effects, and after all the effects layer. AKA the index for a new layer */
+    getEffectIndex(effect: Effect): number;
+    /** Gets the first index that is after all other effect groups */
+    protected getStartingIndex(): number;
+    toJSON(): {
+        name: string;
+        effects: string[];
+    };
+}
+export declare class Channel extends BasicChannel {
+    layers: Map<string, Layer>;
+    groups: EffectGroup[];
+    createGroup(name: string, index?: number): EffectGroup;
+    getGroup(name?: string, index?: number): EffectGroup;
+    private lastOrder;
+    private currentOrder;
+    executor: CommandExecutor;
+    constructor(casparChannel: number, executor?: CommandExecutor);
+    setExecutor(executor: CommandExecutor): void;
+    getLayer(id: string): Layer;
+    getLayers(): Layer[];
+    getLayerIndex(layer: Layer): number;
+    allocateLayers(options?: AllocateOptions): Layer[];
+    private needExecute;
+    allocateLayer(index?: number): Layer;
+    deallocateLayers(layers: Layer[]): void;
+    executeAllocation(): void;
+    toJSON(): {
+        channel: number;
+        layers: {
+            id: string;
+            effect: string;
+        }[];
+        groups: {
+            name: string;
+            effects: string[];
+        }[];
+    };
+}
+export declare class Layer extends BasicLayer {
+    readonly id: string;
+    constructor(channel: Channel);
+    private effect;
+    setEffect(effect: Effect): void;
+    getEffect(): Effect;
+    dispose(): void;
+    toJSON(): {
+        id: string;
+        effect: string;
+    };
+}

package/dist/plugin.d.ts

@@ -1,55 +1,54 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { Effect, EffectConstructor } from './effect';
-import { Logger, CasparManager } from './types';
-import { Method, WebsocketOutboundMethod } from 'rest-exchange-protocol';
-import { Route } from 'rest-exchange-protocol/dist/route';
-import { UI_INJECTION_ZONE } from './types/ui';
-import { RundownItem } from './types/rundown';
-export declare class CasparPlugin {
-    private _api;
-    private _enabled;
-    protected logger: Logger;
-    static get pluginName(): string;
-    get pluginName(): any;
-    private enable;
-    private disable;
-    protected onEnable(): void;
-    protected onDisable(): void;
-    protected get api(): PluginAPI;
-}
-export declare class PluginAPI extends EventEmitter {
-    private files;
-    private uiInjections;
-    private readonly _manager;
-    private readonly _plugin;
-    constructor(_manager: CasparManager, _plugin: CasparPlugin);
-    private _effects;
-    private routes;
-    registerEffect(name: string, effect: EffectConstructor): void;
-    private unregisterEffects;
-    private unregisterRoutes;
-    private unregisterFiles;
-    private unregisterUIInjections;
-    private unregister;
-    registerRoute(path: string, handler: Route['handler'], method: Method): Route;
-    unregisterRoute(route: Route): void;
-    broadcast(target: string, method: WebsocketOutboundMethod, data: any, exclude?: any): void;
-    registerFile(type: 'media' | 'template', path: string): Promise<import("./types/scanner/dir").InternalMediaData>;
-    getEffectGroup(name: string, index?: number): import("./layers").EffectGroup;
-    unregisterFile(id: string): Promise<void>;
-    getDirectory(id: string): Promise<import("./types/scanner/dir").InternalMediaData>;
-    getDirectories(): Promise<import("./types/scanner/dir").InternalMediaData>[];
-    getFileDatabase(): import("./types/scanner/db").FileDatabase;
-    /**
-     * @param injectionZone The zone to inject the file into, e.g. UI_INJECTION_ZONE.EFFECT_CREATOR for the effect creator
-     * @param file The file to inject, it holds the component as default export
-     */
-    registerUI(injectionZone: UI_INJECTION_ZONE, file: string): void;
-    unregisterUI(id: string): void;
-    createEffect<T = Effect>(name: string, group: string, options: any): T;
-    getEffect(id: string): Effect;
-    registerRundownAction(name: string, handler: (item: RundownItem) => Promise<void> | void): void;
-    enableVideoRoute(id: string): void;
-    disableVideoRoute(id: string): void;
-}
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Effect, EffectConstructor } from './effect';
+import { Logger, CasparManager } from './types';
+import { Method, WebsocketOutboundMethod } from 'rest-exchange-protocol';
+import { Route } from 'rest-exchange-protocol/dist/route';
+import { UI_INJECTION_ZONE } from './types/ui';
+import { RundownItem } from './types/rundown';
+export declare class CasparPlugin {
+    private _api;
+    private _enabled;
+    protected logger: Logger;
+    static get pluginName(): string;
+    get pluginName(): any;
+    private enable;
+    private disable;
+    protected onEnable(): void;
+    protected onDisable(): void;
+    protected get api(): PluginAPI;
+}
+export declare class PluginAPI extends EventEmitter {
+    private files;
+    private uiInjections;
+    private readonly _manager;
+    private readonly _plugin;
+    constructor(_manager: CasparManager, _plugin: CasparPlugin);
+    private _effects;
+    private routes;
+    registerEffect(name: string, effect: EffectConstructor): void;
+    private unregisterEffects;
+    private unregisterRoutes;
+    private unregisterFiles;
+    private unregisterUIInjections;
+    private unregister;
+    registerRoute(path: string, handler: Route['handler'], method: Method): Route;
+    unregisterRoute(route: Route): void;
+    broadcast(target: string, method: WebsocketOutboundMethod, data: any, exclude?: any): void;
+    registerFile(type: 'media' | 'template', path: string): Promise<import("./types/scanner/dir").InternalMediaData>;
+    getEffectGroup(name: string, index?: number): import("./layers").EffectGroup;
+    unregisterFile(id: string): Promise<void>;
+    getDirectory(id: string): Promise<import("./types/scanner/dir").InternalMediaData>;
+    getDirectories(): Promise<import("./types/scanner/dir").InternalMediaData>[];
+    getFileDatabase(): import("./types/scanner/db").FileDatabase;
+    /**
+     * @param injectionZone The zone to inject the file into, e.g. UI_INJECTION_ZONE.EFFECT_CREATOR for the effect creator
+     * @param file The file to inject, it holds the component as default export
+     */
+    registerUI(injectionZone: UI_INJECTION_ZONE, file: string): void;
+    unregisterUI(id: string): void;
+    createEffect<T = Effect>(name: string, group: string, options: any): T;
+    getEffect(id: string): Effect;
+    registerRundownAction(name: string, handler: (item: RundownItem) => Promise<void> | void): void;
+    setVideoRouteEnabled(id: string, enabled?: boolean): void;
+}

package/dist/transform.d.ts

@@ -1,46 +1,46 @@
-import { MixerCommand, Tween } from './commands/mixer';
-export interface Point {
-    x: number;
-    y: number;
-}
-export interface Rect {
-    start: Point;
-    end: Point;
-}
-type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
-type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
-export declare class Transform {
-    source: Rect;
-    destination: Rect;
-    fillTransition: Tween;
-    cropTransition: Tween;
-    constructor(source: Rect, destination: Rect);
-    static getRect(sx: number, sy: number, ex: number, ey: number): {
-        start: {
-            x: number;
-            y: number;
-        };
-        end: {
-            x: number;
-            y: number;
-        };
-    };
-    static normalRect(): {
-        start: {
-            x: number;
-            y: number;
-        };
-        end: {
-            x: number;
-            y: number;
-        };
-    };
-    static fromArray(arr: Tuple<number, 8>): Transform;
-    setTween(): any;
-    setTween(tween: Tween): any;
-    setTween(fillTween: Tween, cropTween: Tween): any;
-    private getFill;
-    private getClip;
-    getCommand(): MixerCommand;
-}
-export {};
+import { MixerCommand, Tween } from './commands/mixer';
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect {
+    start: Point;
+    end: Point;
+}
+type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
+type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+export declare class Transform {
+    source: Rect;
+    destination: Rect;
+    fillTransition: Tween;
+    cropTransition: Tween;
+    constructor(source: Rect, destination: Rect);
+    static getRect(sx: number, sy: number, ex: number, ey: number): {
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    };
+    static normalRect(): {
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    };
+    static fromArray(arr: Tuple<number, 8>): Transform;
+    setTween(): any;
+    setTween(tween: Tween): any;
+    setTween(fillTween: Tween, cropTween: Tween): any;
+    private getFill;
+    private getClip;
+    getCommand(): MixerCommand;
+}
+export {};

package/dist/types/caspar/executor.d.ts

@@ -1,11 +1,11 @@
-import { CommandExecutor } from '../../executor';
-import { EffectGroup } from '../../layers';
-export declare class CasparExecutor extends CommandExecutor {
-    readonly ip: string;
-    readonly port: number;
-    private constructor();
-    connect(): void;
-    disconnect(): void;
-    get connected(): boolean;
-    getEffectGroup(identifier: string, index?: number): EffectGroup;
-}
+import { CommandExecutor } from '../../executor';
+import { EffectGroup } from '../../layers';
+export declare class CasparExecutor extends CommandExecutor {
+    readonly ip: string;
+    readonly port: number;
+    private constructor();
+    connect(): void;
+    disconnect(): void;
+    get connected(): boolean;
+    getEffectGroup(identifier: string, index?: number): EffectGroup;
+}

package/dist/types/caspar/process.d.ts

@@ -1,14 +1,14 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-export declare class CasparProcess extends EventEmitter {
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    restart(): Promise<void>;
-    get running(): boolean;
-    getStatus(): {
-        running: boolean;
-    };
-    appendLog(data: string): void;
-    getLogs(): string;
-    get log(): string;
-}
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare class CasparProcess extends EventEmitter {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    get running(): boolean;
+    getStatus(): {
+        running: boolean;
+    };
+    appendLog(data: string): void;
+    getLogs(): string;
+    get log(): string;
+}

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export * from './manager';
-export * from './log';
-export * from './ui';
-export { MediaDoc } from './scanner/db';
+export * from './manager';
+export * from './log';
+export * from './ui';
+export { MediaDoc } from './scanner/db';

package/dist/types/log.d.ts

@@ -1,19 +1,19 @@
-export declare enum LogLevel {
-    INFO = "INFO",
-    WARN = "WARN",
-    DEBUG = "DEBUG",
-    ERROR = "ERROR",
-    FATAL = "FATAL",
-    NONE = "NONE"
-}
-export declare class Logger {
-    private constructor();
-    log(level: LogLevel, message: string): void;
-    scope(scope: string): Logger;
-    info(message: string): void;
-    warn(message: string): void;
-    error(message: string | Error): void;
-    debug(message: string): void;
-    fatal(message: string | Error): void;
-    print(message: string): void;
-}
+export declare enum LogLevel {
+    INFO = "INFO",
+    WARN = "WARN",
+    DEBUG = "DEBUG",
+    ERROR = "ERROR",
+    FATAL = "FATAL",
+    NONE = "NONE"
+}
+export declare class Logger {
+    private constructor();
+    log(level: LogLevel, message: string): void;
+    scope(scope: string): Logger;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string | Error): void;
+    debug(message: string): void;
+    fatal(message: string | Error): void;
+    print(message: string): void;
+}

package/dist/types/manager.d.ts

@@ -1,37 +1,37 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { Injection, UIInjector } from './ui';
-import { EffectRegistry } from '../effect';
-import { Logger } from './log';
-import { MediaScanner } from './scanner/scanner';
-import { DirectoryManager } from './scanner/dir';
-import { CGServer } from './server';
-import { PluginManager } from './plugin';
-import { CasparProcess } from './caspar/process';
-import { CasparExecutor } from './caspar/executor';
-import { FileDatabase } from './scanner/db';
-import { RundownManager } from './rundown';
-import { VideoRoutesManager } from './routes';
-export declare class CasparManager extends EventEmitter {
-    effects: EffectRegistry;
-    ui: UIInjector;
-    scanner: MediaScanner;
-    server: CGServer;
-    plugins: PluginManager;
-    caspar: CasparProcess;
-    executor: CasparExecutor;
-    db: FileDatabase;
-    rundowns: RundownManager;
-    routes: VideoRoutesManager;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getMediaScanner(): MediaScanner;
-    get directory(): DirectoryManager;
-    getPlugins(): PluginManager;
-    getCasparProcess(): CasparProcess;
-    getExecutor(): CasparExecutor;
-    getFiles(): FileDatabase;
-    getPluginInjections(): Injection[];
-    getPluginInjectionCode(id: string): Promise<string>;
-    getLogger(scope: string): Logger;
-}
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Injection, UIInjector } from './ui';
+import { EffectRegistry } from '../effect';
+import { Logger } from './log';
+import { MediaScanner } from './scanner/scanner';
+import { DirectoryManager } from './scanner/dir';
+import { CGServer } from './server';
+import { PluginManager } from './plugin';
+import { CasparProcess } from './caspar/process';
+import { CasparExecutor } from './caspar/executor';
+import { FileDatabase } from './scanner/db';
+import { RundownManager } from './rundown';
+import { VideoRoutesManager } from './routes';
+export declare class CasparManager extends EventEmitter {
+    effects: EffectRegistry;
+    ui: UIInjector;
+    scanner: MediaScanner;
+    server: CGServer;
+    plugins: PluginManager;
+    caspar: CasparProcess;
+    executor: CasparExecutor;
+    db: FileDatabase;
+    rundowns: RundownManager;
+    routes: VideoRoutesManager;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getMediaScanner(): MediaScanner;
+    get directory(): DirectoryManager;
+    getPlugins(): PluginManager;
+    getCasparProcess(): CasparProcess;
+    getExecutor(): CasparExecutor;
+    getFiles(): FileDatabase;
+    getPluginInjections(): Injection[];
+    getPluginInjectionCode(id: string): Promise<string>;
+    getLogger(scope: string): Logger;
+}

package/dist/types/plugin.d.ts

@@ -1,10 +1,10 @@
-import { CasparPlugin } from '../plugin';
-export declare class PluginManager {
-    register(plugin: typeof CasparPlugin): void;
-    unregister(plugin: CasparPlugin): void;
-    enableAll(): void;
-    disableAll(): void;
-    get plugins(): CasparPlugin[];
-    get enabled(): boolean;
-    broadcast(event: string, ...args: any[]): void;
-}
+import { CasparPlugin } from '../plugin';
+export declare class PluginManager {
+    register(plugin: typeof CasparPlugin): void;
+    unregister(plugin: CasparPlugin): void;
+    enableAll(): void;
+    disableAll(): void;
+    get plugins(): CasparPlugin[];
+    get enabled(): boolean;
+    broadcast(event: string, ...args: any[]): void;
+}

package/dist/types/routes.d.ts

@@ -1,47 +1,46 @@
-import { CasparManager } from '../index';
-interface DecklinkSource {
-    device: number;
-    format: string;
-    type: 'decklink';
-}
-interface VideoSource {
-    video: string;
-    type: 'video';
-}
-interface ChannelSource {
-    channel: number;
-    type: 'channel';
-}
-interface ColorSource {
-    color: string;
-    type: 'color';
-}
-interface EffectGroupDestination {
-    effectLayer: string;
-    index?: number;
-    type: 'effect-group';
-}
-type Source = DecklinkSource | VideoSource | ChannelSource | ColorSource;
-type Destination = EffectGroupDestination;
-export interface VideoRoute {
-    id: string;
-    name: string;
-    transform?: number[];
-    source: Source;
-    destination: Destination;
-    enabled: boolean;
-    metadata?: Record<string, any>;
-}
-export declare class VideoRoutesManager {
-    constructor(manager: CasparManager);
-    createVideoRoute(data: Omit<VideoRoute, 'id'>): VideoRoute;
-    getVideoRoute(id: string): VideoRoute | null;
-    getVideoRoutes(): VideoRoute[];
-    updateVideoRoute(data: VideoRoute): Promise<void>;
-    loadVideoRoutes(): Promise<void>;
-    saveVideoRoute(route: VideoRoute): Promise<void>;
-    deleteVideoRoute(id: string): Promise<void>;
-    enableVideoRoute(id: string): any;
-    disableVideoRoute(id: string): any;
-}
-export {};
+import { CasparManager } from '../index';
+interface DecklinkSource {
+    device: number;
+    format: string;
+    type: 'decklink';
+}
+interface VideoSource {
+    video: string;
+    type: 'video';
+}
+interface ChannelSource {
+    channel: number;
+    type: 'channel';
+}
+interface ColorSource {
+    color: string;
+    type: 'color';
+}
+interface EffectGroupDestination {
+    effectLayer: string;
+    index?: number;
+    type: 'effect-group';
+}
+type Source = DecklinkSource | VideoSource | ChannelSource | ColorSource;
+type Destination = EffectGroupDestination;
+export interface VideoRoute {
+    id: string;
+    name: string;
+    transform?: number[];
+    source: Source;
+    destination: Destination;
+    enabled: boolean;
+    metadata?: Record<string, any>;
+}
+export declare class VideoRoutesManager {
+    constructor(manager: CasparManager);
+    createVideoRoute(data: Omit<VideoRoute, 'id'>): VideoRoute;
+    getVideoRoute(id: string): VideoRoute | null;
+    getVideoRoutes(): VideoRoute[];
+    updateVideoRoute(data: VideoRoute): Promise<void>;
+    loadVideoRoutes(): Promise<void>;
+    saveVideoRoute(route: VideoRoute): Promise<void>;
+    deleteVideoRoute(id: string): Promise<void>;
+    setVideoRouteEnabled(id: string, enabled: boolean): any;
+}
+export {};