@lappis/cg-manager 0.0.26 → 0.0.28

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Lapplandsveckan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2024 Lapplandsveckan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/dist/basic.d.ts

@@ -1,22 +1,22 @@
-import { Allocation } from './command';
-export declare class BasicChannel {
-    protected readonly casparChannel: number;
-    constructor(casparChannel: number);
-    getCasparChannel(): number;
-    getCommandString(): string;
-}
-export declare class BasicLayer {
-    protected channel: BasicChannel;
-    protected casparLayer: number;
-    constructor(channel: BasicChannel);
-    static caspar(channel: BasicLayer): any;
-    static caspar(channel: BasicChannel, layer?: number): any;
-    static caspar(channel: number, layer?: number): any;
-    static from(channel: Allocation, layer?: number): BasicChannel | BasicLayer;
-    protected setChannel(channel: BasicChannel): void;
-    protected setCasparLayer(layer: number): void;
-    protected onMove(): void;
-    getCasparLayer(): number;
-    getCasparChannel(): number;
-    getCommandString(): string;
-}
+import { Allocation } from './command';
+export declare class BasicChannel {
+    protected readonly casparChannel: number;
+    constructor(casparChannel: number);
+    getCasparChannel(): number;
+    getCommandString(): string;
+}
+export declare class BasicLayer {
+    protected channel: BasicChannel;
+    protected casparLayer: number;
+    constructor(channel: BasicChannel);
+    static caspar(channel: BasicLayer): any;
+    static caspar(channel: BasicChannel, layer?: number): any;
+    static caspar(channel: number, layer?: number): any;
+    static from(channel: Allocation, layer?: number): BasicChannel | BasicLayer;
+    protected setChannel(channel: BasicChannel): void;
+    protected setCasparLayer(layer: number): void;
+    protected onMove(): void;
+    getCasparLayer(): number;
+    getCasparChannel(): number;
+    getCommandString(): string;
+}

package/dist/command.d.ts

@@ -1,48 +1,48 @@
-import { BasicChannel, BasicLayer } from './basic';
-export declare abstract class Command {
-    abstract getCommand(): string | undefined | void;
-}
-export type ChannelResolvable = BasicChannel | number;
-export type Allocation = BasicLayer | ChannelResolvable;
-export declare abstract class BasicCommand {
-    protected abstract getCommandType(): string;
-    protected abstract getArguments(): string[];
-    private static create;
-    private static parseQuotes;
-    private static parseArguments;
-    static from(command: string): ReturnType<typeof BasicCommand.create>;
-    static interpret(command: string): ReturnType<typeof BasicCommand.create>[];
-    protected compileArgs(): string;
-    getCommand(): string;
-}
-export declare abstract class LayeredCommand extends BasicCommand {
-    protected allocation?: BasicLayer | BasicChannel;
-    constructor(allocation?: BasicLayer | BasicChannel);
-    allocate(channel: Allocation): any;
-    allocate(channel: ChannelResolvable, layer: number): any;
-    protected isChannel(): boolean;
-    protected isLayer(): boolean;
-    protected getPosition(): string;
-}
-export declare abstract class SimpleCommand extends LayeredCommand {
-    protected getArguments(): string[];
-}
-export declare abstract class SimpleArgsCommand extends SimpleCommand {
-    protected args: string[];
-    constructor(...args: string[]);
-    setArgs(...args: string[]): this;
-    protected getArguments(): string[];
-}
-export declare class CommandGroup extends Command {
-    protected readonly commands: Command[];
-    protected allocation?: BasicLayer | BasicChannel;
-    constructor(commands: Command[]);
-    allocate(channel: Allocation): any;
-    allocate(channel: ChannelResolvable, layer: number): any;
-    getCommand(): string;
-}
-export declare class RawCommand extends Command {
-    private readonly command;
-    constructor(command: string);
-    getCommand(): string;
-}
+import { BasicChannel, BasicLayer } from './basic';
+export declare abstract class Command {
+    abstract getCommand(): string | undefined | void;
+}
+export type ChannelResolvable = BasicChannel | number;
+export type Allocation = BasicLayer | ChannelResolvable;
+export declare abstract class BasicCommand {
+    protected abstract getCommandType(): string;
+    protected abstract getArguments(): string[];
+    private static create;
+    private static parseQuotes;
+    private static parseArguments;
+    static from(command: string): ReturnType<typeof BasicCommand.create>;
+    static interpret(command: string): ReturnType<typeof BasicCommand.create>[];
+    protected compileArgs(): string;
+    getCommand(): string;
+}
+export declare abstract class LayeredCommand extends BasicCommand {
+    protected allocation?: BasicLayer | BasicChannel;
+    constructor(allocation?: BasicLayer | BasicChannel);
+    allocate(channel: Allocation): any;
+    allocate(channel: ChannelResolvable, layer: number): any;
+    protected isChannel(): boolean;
+    protected isLayer(): boolean;
+    protected getPosition(): string;
+}
+export declare abstract class SimpleCommand extends LayeredCommand {
+    protected getArguments(): string[];
+}
+export declare abstract class SimpleArgsCommand extends SimpleCommand {
+    protected args: string[];
+    constructor(...args: string[]);
+    setArgs(...args: string[]): this;
+    protected getArguments(): string[];
+}
+export declare class CommandGroup extends Command {
+    protected readonly commands: Command[];
+    protected allocation?: BasicLayer | BasicChannel;
+    constructor(commands: Command[]);
+    allocate(channel: Allocation): any;
+    allocate(channel: ChannelResolvable, layer: number): any;
+    getCommand(): string;
+}
+export declare class RawCommand extends Command {
+    private readonly command;
+    constructor(command: string);
+    getCommand(): string;
+}

package/dist/commands/add.d.ts

@@ -1,4 +1,4 @@
-import { SimpleArgsCommand } from '../command';
-export declare class AddCommand extends SimpleArgsCommand {
-    protected getCommandType(): string;
-}
+import { SimpleArgsCommand } from '../command';
+export declare class AddCommand extends SimpleArgsCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/call.d.ts

@@ -1,9 +1,9 @@
-import { LayeredCommand } from '../command';
-export declare class CallCommand extends LayeredCommand {
-    private method;
-    constructor(method?: string);
-    static call(method: string): CallCommand;
-    setMethod(method: string): this;
-    protected getCommandType(): string;
-    protected getArguments(): string[];
-}
+import { LayeredCommand } from '../command';
+export declare class CallCommand extends LayeredCommand {
+    private method;
+    constructor(method?: string);
+    static call(method: string): CallCommand;
+    setMethod(method: string): this;
+    protected getCommandType(): string;
+    protected getArguments(): string[];
+}

package/dist/commands/cg.d.ts

@@ -1,20 +1,20 @@
-import { LayeredCommand } from '../command';
-export declare class CgCommand extends LayeredCommand {
-    private cmd;
-    private cgLayer?;
-    private arguments;
-    constructor();
-    setLayer(layer: number): this;
-    private static single;
-    static add(templateName: string, playOnLoad?: boolean, data?: any): CgCommand;
-    static play(): CgCommand;
-    static stop(): CgCommand;
-    static next(): CgCommand;
-    static remove(): CgCommand;
-    static clear(): CgCommand;
-    static update(data: any): CgCommand;
-    static invoke(method: string): CgCommand;
-    static info(): CgCommand;
-    getCommandType(): string;
-    getArguments(): string[];
-}
+import { LayeredCommand } from '../command';
+export declare class CgCommand extends LayeredCommand {
+    private cmd;
+    private cgLayer?;
+    private arguments;
+    constructor();
+    setLayer(layer: number): this;
+    private static single;
+    static add(templateName: string, playOnLoad?: boolean, data?: any): CgCommand;
+    static play(): CgCommand;
+    static stop(): CgCommand;
+    static next(): CgCommand;
+    static remove(): CgCommand;
+    static clear(): CgCommand;
+    static update(data: any): CgCommand;
+    static invoke(method: string): CgCommand;
+    static info(): CgCommand;
+    getCommandType(): string;
+    getArguments(): string[];
+}

package/dist/commands/clear.d.ts

@@ -1,5 +1,5 @@
-import { RawCommand, SimpleCommand } from '../command';
-export declare class ClearCommand extends SimpleCommand {
-    protected getCommandType(): string;
-    static all(): RawCommand;
-}
+import { RawCommand, SimpleCommand } from '../command';
+export declare class ClearCommand extends SimpleCommand {
+    protected getCommandType(): string;
+    static all(): RawCommand;
+}

package/dist/commands/load.d.ts

@@ -1,4 +1,4 @@
-import { LoadBGCommand } from './loadbg';
-export declare class LoadCommand extends LoadBGCommand {
-    protected getCommandType(): string;
-}
+import { LoadBGCommand } from './loadbg';
+export declare class LoadCommand extends LoadBGCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/loadbg.d.ts

@@ -1,42 +1,42 @@
-import { LayeredCommand } from '../command';
-import { BasicChannel, BasicLayer } from '../basic';
-export declare enum Transition {
-    CUT = "CUT",
-    MIX = "MIX",
-    SLIDE = "SLIDE"
-}
-export declare enum Tween {
-    Linear = "Linear"
-}
-export declare enum Direction {
-    LEFT = "LEFT",
-    RIGHT = "RIGHT"
-}
-export interface PlayoutOptions {
-    duration?: number;
-    transition?: Transition;
-    tween?: Tween;
-    direction?: Direction;
-    seek?: number;
-    length?: number;
-    filter?: string;
-    loop?: boolean;
-    auto?: boolean;
-}
-export declare class Color {
-    static RGBA(r: number, g: number, b: number, a?: number): string;
-}
-export declare class Video {
-    static getVideoArguments(options?: PlayoutOptions): string[];
-}
-export declare class LoadBGCommand extends LayeredCommand {
-    private arguments;
-    protected getCommandType(): string;
-    protected getArguments(): string[];
-    constructor();
-    private setArguments;
-    static video(video: string, options?: PlayoutOptions): LoadBGCommand;
-    static decklink(device: number, format: string): LoadBGCommand;
-    static route(source: BasicLayer | BasicChannel): LoadBGCommand;
-    static color(color: string): LoadBGCommand;
-}
+import { LayeredCommand } from '../command';
+import { BasicChannel, BasicLayer } from '../basic';
+export declare enum Transition {
+    CUT = "CUT",
+    MIX = "MIX",
+    SLIDE = "SLIDE"
+}
+export declare enum Tween {
+    Linear = "Linear"
+}
+export declare enum Direction {
+    LEFT = "LEFT",
+    RIGHT = "RIGHT"
+}
+export interface PlayoutOptions {
+    duration?: number;
+    transition?: Transition;
+    tween?: Tween;
+    direction?: Direction;
+    seek?: number;
+    length?: number;
+    filter?: string;
+    loop?: boolean;
+    auto?: boolean;
+}
+export declare class Color {
+    static RGBA(r: number, g: number, b: number, a?: number): string;
+}
+export declare class Video {
+    static getVideoArguments(options?: PlayoutOptions): string[];
+}
+export declare class LoadBGCommand extends LayeredCommand {
+    private arguments;
+    protected getCommandType(): string;
+    protected getArguments(): string[];
+    constructor();
+    private setArguments;
+    static video(video: string, options?: PlayoutOptions): LoadBGCommand;
+    static decklink(device: number, format: string): LoadBGCommand;
+    static route(source: BasicLayer | BasicChannel): LoadBGCommand;
+    static color(color: string): LoadBGCommand;
+}

package/dist/commands/mixer.d.ts

@@ -1,89 +1,89 @@
-import { CommandGroup } from '../command';
-interface ChromaEnabled {
-    enabled: true;
-    target_hue: number;
-    hue_width: number;
-    min_saturation: number;
-    min_brightness: number;
-    softness: number;
-    spill_suppress: number;
-    spill_suppress_saturation: number;
-    show_mask: boolean;
-}
-interface ChromaDisabled {
-    enabled: false;
-}
-type Chrome = ChromaEnabled | ChromaDisabled;
-interface Levels {
-    min_input: number;
-    max_input: number;
-    gamma: number;
-    min_output: number;
-    max_output: number;
-}
-interface Fill {
-    x: number;
-    y: number;
-    x_scale: number;
-    y_scale: number;
-}
-interface Clip {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-interface Anchor {
-    x: number;
-    y: number;
-}
-interface Crop {
-    left_edge: number;
-    top_edge: number;
-    right_edge: number;
-    bottom_edge: number;
-}
-interface Perspective {
-    top_left: Anchor;
-    top_right: Anchor;
-    bottom_right: Anchor;
-    bottom_left: Anchor;
-}
-export type Tween = {
-    type?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
-    duration: number;
-} | number;
-export interface EdgeBlendOptions {
-    edgeblend: [number, number, number, number];
-    g?: number;
-    p?: number;
-    a?: number;
-}
-export declare class MixerCommand extends CommandGroup {
-    constructor(shouldClear?: boolean);
-    protected single(command: string, args?: string[], tween?: Tween): this;
-    static create(): MixerCommand;
-    static clear(): MixerCommand;
-    keyer(keyer: number): this;
-    chroma(chroma: Chrome, tween?: Tween): this;
-    blend(blend: string): this;
-    invert(invert: boolean): this;
-    opacity(opacity: number, tween?: Tween): this;
-    brightness(brightness: number, tween?: Tween): this;
-    saturation(saturation: number, tween?: Tween): this;
-    contrast(contrast: number, tween?: Tween): this;
-    levels(levels: Levels, tween?: Tween): this;
-    fill(fill: Fill, tween?: Tween): this;
-    clip(clip: Clip, tween?: Tween): this;
-    anchor(anchor: Anchor, tween?: Tween): this;
-    crop(crop: Crop, tween?: Tween): this;
-    rotation(angle: number, tween?: Tween): this;
-    perspective(perspective: Perspective, tween?: Tween): this;
-    mipmap(mipmap: boolean): this;
-    volume(volume: number, tween?: Tween): this;
-    mastervolume(volume: number): this;
-    straightAlphaOutput(enabled: boolean): this;
-    edgeblend(edgeblend: EdgeBlendOptions): this;
-    clear(): this;
-}
-export {};
+import { CommandGroup } from '../command';
+interface ChromaEnabled {
+    enabled: true;
+    target_hue: number;
+    hue_width: number;
+    min_saturation: number;
+    min_brightness: number;
+    softness: number;
+    spill_suppress: number;
+    spill_suppress_saturation: number;
+    show_mask: boolean;
+}
+interface ChromaDisabled {
+    enabled: false;
+}
+type Chrome = ChromaEnabled | ChromaDisabled;
+interface Levels {
+    min_input: number;
+    max_input: number;
+    gamma: number;
+    min_output: number;
+    max_output: number;
+}
+interface Fill {
+    x: number;
+    y: number;
+    x_scale: number;
+    y_scale: number;
+}
+interface Clip {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface Anchor {
+    x: number;
+    y: number;
+}
+interface Crop {
+    left_edge: number;
+    top_edge: number;
+    right_edge: number;
+    bottom_edge: number;
+}
+interface Perspective {
+    top_left: Anchor;
+    top_right: Anchor;
+    bottom_right: Anchor;
+    bottom_left: Anchor;
+}
+export type Tween = {
+    type?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+    duration: number;
+} | number;
+export interface EdgeBlendOptions {
+    edgeblend: [number, number, number, number];
+    g?: number;
+    p?: number;
+    a?: number;
+}
+export declare class MixerCommand extends CommandGroup {
+    constructor(shouldClear?: boolean);
+    protected single(command: string, args?: string[], tween?: Tween): this;
+    static create(): MixerCommand;
+    static clear(): MixerCommand;
+    keyer(keyer: number): this;
+    chroma(chroma: Chrome, tween?: Tween): this;
+    blend(blend: string): this;
+    invert(invert: boolean): this;
+    opacity(opacity: number, tween?: Tween): this;
+    brightness(brightness: number, tween?: Tween): this;
+    saturation(saturation: number, tween?: Tween): this;
+    contrast(contrast: number, tween?: Tween): this;
+    levels(levels: Levels, tween?: Tween): this;
+    fill(fill: Fill, tween?: Tween): this;
+    clip(clip: Clip, tween?: Tween): this;
+    anchor(anchor: Anchor, tween?: Tween): this;
+    crop(crop: Crop, tween?: Tween): this;
+    rotation(angle: number, tween?: Tween): this;
+    perspective(perspective: Perspective, tween?: Tween): this;
+    mipmap(mipmap: boolean): this;
+    volume(volume: number, tween?: Tween): this;
+    mastervolume(volume: number): this;
+    straightAlphaOutput(enabled: boolean): this;
+    edgeblend(edgeblend: EdgeBlendOptions): this;
+    clear(): this;
+}
+export {};

package/dist/commands/pause.d.ts

@@ -1,4 +1,4 @@
-import { SimpleCommand } from '../command';
-export declare class PauseCommand extends SimpleCommand {
-    protected getCommandType(): string;
-}
+import { SimpleCommand } from '../command';
+export declare class PauseCommand extends SimpleCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/play.d.ts

@@ -1,4 +1,4 @@
-import { LoadBGCommand } from './loadbg';
-export declare class PlayCommand extends LoadBGCommand {
-    protected getCommandType(): string;
-}
+import { LoadBGCommand } from './loadbg';
+export declare class PlayCommand extends LoadBGCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/print.d.ts

@@ -1,4 +1,4 @@
-import { SimpleCommand } from '../command';
-export declare class PrintCommand extends SimpleCommand {
-    protected getCommandType(): string;
-}
+import { SimpleCommand } from '../command';
+export declare class PrintCommand extends SimpleCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/remove.d.ts

@@ -1,4 +1,4 @@
-import { SimpleArgsCommand } from '../command';
-export declare class RemoveCommand extends SimpleArgsCommand {
-    protected getCommandType(): string;
-}
+import { SimpleArgsCommand } from '../command';
+export declare class RemoveCommand extends SimpleArgsCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/resume.d.ts

@@ -1,4 +1,4 @@
-import { SimpleCommand } from '../command';
-export declare class ResumeCommand extends SimpleCommand {
-    protected getCommandType(): string;
-}
+import { SimpleCommand } from '../command';
+export declare class ResumeCommand extends SimpleCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/stop.d.ts

@@ -1,4 +1,4 @@
-import { SimpleCommand } from '../command';
-export declare class StopCommand extends SimpleCommand {
-    protected getCommandType(): string;
-}
+import { SimpleCommand } from '../command';
+export declare class StopCommand extends SimpleCommand {
+    protected getCommandType(): string;
+}

package/dist/commands/swap.d.ts

@@ -1,15 +1,15 @@
-import { Allocation, BasicCommand, ChannelResolvable } from '../command';
-import { BasicChannel, BasicLayer } from '../basic';
-export declare class SwapCommand extends BasicCommand {
-    protected allocation1?: BasicLayer | BasicChannel;
-    protected allocation2?: BasicLayer | BasicChannel;
-    protected transforms: boolean;
-    constructor();
-    constructor(allocation1: Allocation, allocation2: Allocation, transforms?: boolean);
-    allocate1(channel: Allocation): any;
-    allocate1(channel: ChannelResolvable, layer: number): any;
-    allocate2(channel: Allocation): any;
-    allocate2(channel: ChannelResolvable, layer: number): any;
-    protected getCommandType(): string;
-    protected getArguments(): string[];
-}
+import { Allocation, BasicCommand, ChannelResolvable } from '../command';
+import { BasicChannel, BasicLayer } from '../basic';
+export declare class SwapCommand extends BasicCommand {
+    protected allocation1?: BasicLayer | BasicChannel;
+    protected allocation2?: BasicLayer | BasicChannel;
+    protected transforms: boolean;
+    constructor();
+    constructor(allocation1: Allocation, allocation2: Allocation, transforms?: boolean);
+    allocate1(channel: Allocation): any;
+    allocate1(channel: ChannelResolvable, layer: number): any;
+    allocate2(channel: Allocation): any;
+    allocate2(channel: ChannelResolvable, layer: number): any;
+    protected getCommandType(): string;
+    protected getArguments(): string[];
+}