@media-quest/engine 0.0.14 → 0.0.15

package/src/services/DMedia-manager.ts

@@ -1,179 +0,0 @@
-import { PageDto } from "../dto/SchemaDto";
-import { VideoContainer } from "../Delement/VideoContainer";
-import { AudioContainer } from "../Delement/AudioContainer";
-import { AutoPlayElement, DAutoPlaySequence } from "../Delement/DAuto-play";
-import { DCommandBus } from "../commands/DCommandBus";
-import { DCommand } from "../commands/DCommand";
-import { DTimestamp } from "../common/DTimestamp";
-import { EventBus } from "../events/event-bus";
-import { ScaleService } from "../engine/scale";
-import { ResourceProvider } from "./resource-provider";
-import { AutoplayTask, SequenceManager } from "./sequence-manager";
-
-export interface IMediaManager {
-  setPage(page: PageDto): void;
-  destroy(): void;
-}
-
-export class DMediaManager implements IMediaManager {
-  private static INSTANCE_COUNT = 0;
-  private readonly instanceNumber: number;
-  private readonly TAG = "[ MEDIA_MANAGER ] : ";
-  private readonly videoContainer: VideoContainer;
-  private readonly audioContainer: AudioContainer;
-  private pageEnter: DTimestamp;
-  private sincePageEnter: DTimestamp.Diff;
-  private currentPage: PageDto | null = null;
-  private readonly unsubscribeCommands: () => void;
-  private readonly tickerRef: number;
-  private readonly sequenceManager: SequenceManager | false = false;
-  constructor(
-    private hostEl: HTMLDivElement,
-    private readonly commandBus: DCommandBus,
-    private readonly eventBus: EventBus,
-    private readonly resourceProvider: ResourceProvider,
-    private readonly scale: ScaleService,
-  ) {
-    DMediaManager.INSTANCE_COUNT = DMediaManager.INSTANCE_COUNT + 1;
-    this.instanceNumber = DMediaManager.INSTANCE_COUNT;
-    const videoEl = document.createElement("video");
-    this.hostEl.append(videoEl);
-    this.videoContainer = new VideoContainer(videoEl, eventBus, this.scale);
-    this.audioContainer = new AudioContainer(this.eventBus);
-    this.tick = this.tick.bind(this);
-    this.videoContainer.setStyle({ visibility: "hidden" });
-    const now = DTimestamp.now();
-    this.pageEnter = now;
-    this.sincePageEnter = DTimestamp.diff(now, now);
-    this.unsubscribeCommands = this.commandBus.subscribe((action) => {
-      this.commandHandler(action);
-    }, this.TAG);
-
-    this.tickerRef = window.setInterval(() => {}, 1000);
-  }
-
-  /**
-   * Stop all media that is playing
-   */
-  clearAllMedia() {
-    this.videoContainer.pause();
-    this.audioContainer.pause();
-  }
-  destroy() {
-    console.log("TODO DESTROY ALL MEDIA");
-    this.unsubscribeCommands();
-    // console.log(this.tickerRef);
-    window.clearInterval(this.tickerRef);
-    this.audioContainer.destroy();
-    this.videoContainer.destroy();
-  }
-
-  setPage(page: PageDto) {
-    // TODO STOP VIDEO/AUDIO THAT MIGHT BE PLAYING IN THE DOM??
-    this.currentPage = page;
-    this.videoContainer.pause();
-    this.pageEnter = DTimestamp.now();
-    // TODO THis might be a bug if someone
-
-    const seq = page.autoPlaySequence;
-    // this.sequence = seq ? [...seq.items] : [];
-    const { mainVideoId, audio } = page;
-    const audioElements = page.audio;
-
-    if (mainVideoId) {
-      const dto = this.resourceProvider.getVideoById(mainVideoId);
-      if (dto) {
-        this.videoContainer.setDto(dto);
-        this.videoContainer.setStyle({ ...dto.style, visibility: "visible" });
-      }
-      // this.videoContainer.playToEnd();
-    } else {
-      this.videoContainer.setStyle({ visibility: "hidden" });
-      // HIDE?
-    }
-    if (audioElements) {
-      const first = audioElements[0];
-      if (first) {
-        this.audioContainer.setAudio(first);
-      }
-    }
-    if (seq) {
-      this.playSequence(seq);
-    }
-    // const hasVideo =
-  }
-
-  private commandHandler(command: DCommand) {
-    if (command.kind === "VIDEO_PLAY_COMMAND") {
-      const video = command.targetId;
-      const dto = this.videoContainer.getCurrentDto();
-
-      if (dto && dto.id === command.targetId) {
-        console.log(video);
-        this.videoContainer.play(dto.url);
-      }
-    }
-    if (command.kind === "VIDEO_PAUSE_COMMAND") {
-      this.videoContainer.pause();
-    }
-    if (command.kind === "AUDIO_PLAY_COMMAND") {
-      this.audioContainer
-        .playToEnd()
-        .then(() => {})
-        .catch()
-        .finally(() => {});
-    }
-
-    if (command.kind === "AUDIO_PAUSE_COMMAND") {
-      // this.audioContainer.
-    }
-  }
-
-  private async playSequence(seq: DAutoPlaySequence) {
-    // console.log(this.TAG + "SEQUENCE STARTED -- TODO EVENT FOR THIS??");
-
-    const elements = seq.items;
-    const testClone = [...elements];
-    const first = testClone.pop();
-
-    if (!first) {
-      return false;
-    }
-    const now = DTimestamp.now();
-    seq.startCommands.forEach((c) => {
-      console.log(c);
-      this.commandBus.emit(c);
-    });
-    // this.commandBus.emit(DStateProps.mediaBlockedBySequence.setTrueCommand);
-    // if (seq.blockUserInput) {
-    //     this.commandBus.emit(DStateProps.inputBlockingBySequence.getSetTrueCommand());
-    // }
-    for (let i = 0; i < elements.length; i++) {
-      const item = elements[i];
-      if (item.kind === "autoplay-video") {
-        const dto = this.resourceProvider.getVideoById(item.videoId);
-        if (dto) this.videoContainer.setDto(dto);
-        await this.videoContainer.playToEnd();
-      }
-      if (item.kind === "autoplay-audio") {
-        console.log(item);
-        const dto = this.resourceProvider.getAudioById(item.audioId);
-        if (dto) this.audioContainer.setAudio(dto);
-        await this.audioContainer.playToEnd();
-      }
-    }
-    seq.endCommands.forEach((c) => {
-      this.commandBus.emit(c);
-    });
-    // this.actionService.emit(DStateProps.mediaBlockedBySequence.setFalseCommand);
-    // this.actionService.emit(DStateProps.inputBlockingBySequence.setFalseCommand);
-    console.log(this.TAG + "SEQUENCE ENDED");
-    return true;
-  }
-
-  // setPage()
-
-  private tick() {
-    // console.log(this.video1.getStats());
-  }
-}

package/src/services/resource-provider.ts

@@ -1,33 +0,0 @@
-import { DAudioDto, DImgDto, DVideoDto } from "../dto/DElement.dto";
-
-export class ResourceProvider {
-    private readonly TAG = "[ RESOURCE_PROVIDER ]: ";
-    private readonly videoMap = new Map<string, DVideoDto>();
-    private readonly audioMap = new Map<string, DAudioDto>();
-    constructor(data: { videos: ReadonlyArray<DVideoDto>; audio: ReadonlyArray<DAudioDto> }) {
-        // console.log(this.TAG + "VIDEO_COUNT " + data.videos.length);
-        // console.log(this.TAG + "AUDIO_COUNT " + data.audio.length);
-        data.videos.forEach((video) => {
-            this.videoMap.set(video.id, video);
-        });
-        data.audio.forEach((audio) => {
-            this.audioMap.set(audio.id, audio);
-        });
-    }
-
-    getAudioById(id: string): DAudioDto | false {
-        const maybeAudio = this.audioMap.get(id);
-        if (!maybeAudio) {
-            console.error(this.TAG + "Audio by id " + id + " dont exist");
-        }
-        return maybeAudio ?? false;
-    }
-
-    getVideoById(id: string): DVideoDto | false {
-        const maybeVideo = this.videoMap.get(id);
-        if (!maybeVideo) {
-            console.error(this.TAG + "Video by id " + id + " dont exist");
-        }
-        return maybeVideo ?? false;
-    }
-}

package/src/services/sequence-manager.spec.ts

@@ -1,168 +0,0 @@
-import { AudioTask, DelayTask, NoopTask, SequenceManager, VideoTask } from "./sequence-manager";
-import { DTimestamp } from "../common/DTimestamp";
-
-const delayTask = (duration: number): DelayTask => {
-    return { kind: "delay-task", duration };
-};
-const createTimestamps = () => {
-    const t0 = DTimestamp.now();
-    const add = (ms: number) => DTimestamp.addMills(t0, ms);
-    return {
-        t0,
-        t100: add(100),
-        t500: add(500),
-        t600: add(600),
-        t900: add(900),
-        t1000: add(1000),
-        t1020: add(1020),
-        t1100: add(1100),
-        t1200: add(1200),
-        t1500: add(1500),
-        t2000: add(2000),
-        t2100: add(2100),
-        t2500: add(2500),
-        t3000: add(3000),
-        t3001: add(3001),
-        t5000: add(5000),
-        t6000: add(6000),
-        t7000: add(7000),
-        t8000: add(8000),
-        t8500: add(8500),
-        t9000: add(9000),
-        t9500: add(9500),
-    };
-};
-const audioTask = (url: string): AudioTask => {
-    return { kind: "autoplay-audio-task", url, audioId: "id_" + url };
-};
-const videoTask = (url: string): VideoTask => {
-    return { kind: "autoplay-video-task", url, videoId: "id_" + url };
-};
-
-const noopTask: NoopTask = { kind: "noop-task" };
-const delay1000 = delayTask(1000);
-const delay2000 = delayTask(2000);
-const video1 = videoTask("video_1_url");
-const audio1 = audioTask("audio_1_url");
-const sequence1 = [delay1000, video1, delay2000, audio1];
-const manager = (tasks: Array<DelayTask | AudioTask | VideoTask>) => new SequenceManager(tasks);
-describe("Media manager state", () => {
-    test("Empty task array is completed at once:", () => {
-        const m = manager([]);
-        expect(m.isCompleted).toBeTruthy();
-    });
-
-    test("Non empty task-array will be running at creation-time", () => {
-        const m = manager([delayTask(1000), audioTask("url1")]);
-        expect(m.isRunning).toBeTruthy();
-    });
-
-    test("After abort the task", () => {
-        const sm = manager(sequence1);
-        expect(sm.isRunning).toBeTruthy();
-        sm.abort();
-        const nextTask = sm.nextTask(DTimestamp.now());
-        expect(sm.isRunning).toBeFalsy();
-        expect(nextTask).toStrictEqual(noopTask);
-    });
-    test("Fist task will be returned after construction", () => {
-        const sm = manager([video1]);
-        const firstTask = sm.nextTask(DTimestamp.now());
-        expect(firstTask).toStrictEqual(video1);
-        // expect(firstTask).toStrictEqual(noopTask);
-    });
-    test("A task will only be returned once!", () => {
-        const sm = manager([video1, audio1]);
-        const firstTask = sm.nextTask(DTimestamp.now());
-
-        expect(sm.isRunning);
-        expect(firstTask).toStrictEqual(video1);
-        const secondTask = sm.nextTask(DTimestamp.now());
-        expect(secondTask).toStrictEqual(noopTask);
-        expect(sm.isRunning);
-    });
-    test("A delayTask will block other tasks from running.", () => {
-        const t = createTimestamps();
-        const sm = manager([delayTask(1000), video1, audio1]);
-        expect(sm.isRunning);
-        const task0 = sm.nextTask(DTimestamp.now());
-        expect(task0).toStrictEqual(noopTask);
-
-        expect(sm.nextTask(t.t500)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t600)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t900)).toStrictEqual(noopTask);
-
-        // AFTER DELAY
-        expect(sm.nextTask(t.t1020)).toStrictEqual(video1);
-        expect(sm.nextTask(t.t5000)).toStrictEqual(noopTask);
-    });
-    test("A video-task can ble completed.", () => {
-        const t = createTimestamps();
-        const sm = manager([video1, audio1]);
-        expect(sm.isRunning);
-        expect(sm.nextTask(t.t100)).toStrictEqual(video1);
-        expect(sm.nextTask(t.t500)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t2100)).toStrictEqual(noopTask);
-        sm.videoCompleted({ videoId: video1.videoId, url: video1.url });
-        const after = sm.nextTask(t.t3001);
-        expect(after).toStrictEqual(audio1);
-    });
-    test("Many delays can be placed and block on every step.", () => {
-        const t = createTimestamps();
-        const sm = manager([delayTask(1000), video1, delay2000, audio1]);
-        expect(sm.isRunning);
-
-        // FIRST DELAY.
-        expect(sm.nextTask(t.t100)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t600)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t900)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t1020)).toStrictEqual(video1);
-        expect(sm.nextTask(t.t1100)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t1500)).toStrictEqual(noopTask);
-
-        // DELAY 2 -> start at approximately 1500
-        sm.videoCompleted({ videoId: video1.videoId, url: video1.url });
-        expect(sm.nextTask(t.t2100)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t3000)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t5000)).toStrictEqual(audio1);
-        expect(sm.nextTask(t.t6000)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t7000)).toStrictEqual(noopTask);
-        expect(sm.isCompleted).toStrictEqual(false);
-        sm.audioCompleted({ audioId: audio1.audioId, url: audio1.url });
-        expect(sm.isCompleted).toStrictEqual(true);
-    });
-    test("Can complete audio", () => {
-        const t = createTimestamps();
-        const sm = manager([audio1]);
-        expect(sm.isRunning);
-        // FIRST DELAY.
-        expect(sm.nextTask(t.t100)).toStrictEqual(audio1);
-        expect(sm.nextTask(t.t500)).toStrictEqual(noopTask);
-        expect(sm.nextTask(t.t600)).toStrictEqual(noopTask);
-        expect(sm.isCompleted).toStrictEqual(false);
-        sm.audioCompleted({ audioId: audio1.audioId, url: audio1.url });
-        expect(sm.isCompleted).toStrictEqual(true);
-    });
-    test("Can only complete audio with correct url.", () => {
-        const t = createTimestamps();
-        const sm = manager([audio1]);
-        expect(sm.isRunning);
-        // FIRST DELAY.
-        const first = sm.nextTask(t.t100);
-        expect(first).toStrictEqual(audio1);
-        expect(sm.isCompleted).toStrictEqual(false);
-        sm.audioCompleted({ audioId: "bullshit", url: "bullshit" });
-        expect(sm.isCompleted).toStrictEqual(false);
-    });
-    test("Can only complete video with correct url.", () => {
-        const t = createTimestamps();
-        const sm = manager([video1]);
-        expect(sm.isRunning);
-        // FIRST DELAY.
-        const first = sm.nextTask(t.t100);
-        expect(first).toStrictEqual(video1);
-        expect(sm.isCompleted).toStrictEqual(false);
-        sm.videoCompleted({ videoId: "bullshit", url: "bullshit" });
-        expect(sm.isCompleted).toStrictEqual(false);
-    });
-});

package/src/services/sequence-manager.ts

@@ -1,133 +0,0 @@
-import { DTimestamp } from "../common/DTimestamp";
-
-export interface DelayTask {
-  readonly kind: "delay-task";
-  readonly duration: number;
-}
-
-export interface NoopTask {
-  readonly kind: "noop-task";
-}
-
-export interface AudioTask {
-  readonly kind: "autoplay-audio-task";
-  readonly url: string;
-  readonly audioId: string;
-}
-
-export interface VideoTask {
-  readonly kind: "autoplay-video-task";
-  readonly url: string;
-  readonly videoId: string;
-}
-
-export type AutoplayTask = VideoTask | AudioTask | DelayTask;
-type TaskHistory = {
-  readonly startedAt: DTimestamp;
-  readonly completedAt: DTimestamp;
-  readonly task: AutoplayTask;
-};
-class SequenceHistory {
-  private taskHistory: Array<TaskHistory> = [];
-  constructor(private readonly startedAt: DTimestamp) {}
-
-  add(task: TaskHistory) {
-    this.taskHistory.push(task);
-  }
-}
-
-export class SequenceManager {
-  private runningTask: { task: AutoplayTask; startedAt: DTimestamp } | false;
-  private taskList: Array<DelayTask | AudioTask | VideoTask>;
-  private readonly t0: DTimestamp;
-  private readonly history: SequenceHistory;
-
-  constructor(private readonly tasks: ReadonlyArray<AudioTask | DelayTask | VideoTask>) {
-    this.t0 = DTimestamp.now();
-    const [first, ...rest] = tasks;
-    if (first && first.kind === "delay-task") {
-      this.runningTask = { task: first, startedAt: this.t0 };
-      this.taskList = [...rest];
-    } else {
-      this.runningTask = false;
-      this.taskList = [...tasks];
-    }
-    this.history = new SequenceHistory(this.t0);
-  }
-
-  audioCompleted(audio: { audioId: string; url: string }) {
-    const curr = this.runningTask;
-    if (curr && curr.task.kind === "autoplay-audio-task") {
-      const { audioId, url } = curr.task;
-      if (url === audio.url) {
-        this.runningTask = false;
-      } else {
-        // WARN ABOUT UNEXPECTED AUDIO ID && URL ??
-        console.warn("Unexpected audio completed url.");
-      }
-    }
-  }
-
-  videoCompleted(video: { videoId: string; url: string }) {
-    const curr = this.runningTask;
-    if (curr && curr.task.kind === "autoplay-video-task") {
-      const { url } = curr.task;
-      if (url === video.url) {
-        this.runningTask = false;
-      } else {
-        // WARN ABOUT UNEXPECTED AUDIO ID && URL ??
-        console.warn("Unexpected video completed url.");
-      }
-    }
-  }
-
-  abort() {
-    this.taskList = [];
-    this.runningTask = false;
-  }
-  get isCompleted() {
-    return !this.isRunning;
-  }
-  get isRunning() {
-    return this.runningTask || this.taskList.length;
-  }
-
-  nextTask(now: DTimestamp): NoopTask | AudioTask | VideoTask {
-    const curr = this.runningTask;
-
-    if (curr && curr.task.kind === "delay-task") {
-      const progress = DTimestamp.diff(curr.startedAt, now);
-      // DELAY COMPLETED.
-      if (progress >= curr.task.duration) {
-        this.runningTask = false;
-      }
-    }
-
-    // RETURN IF A TASK IS RUNNING.
-    if (this.runningTask) {
-      return { kind: "noop-task" };
-    }
-
-    const first = this.taskList.shift();
-    if (!first) {
-      return { kind: "noop-task" };
-    }
-
-    if (first.kind === "delay-task") {
-      this.runningTask = { task: first, startedAt: now };
-      return { kind: "noop-task" };
-    }
-
-    if (first.kind === "autoplay-video-task") {
-      this.runningTask = { task: first, startedAt: now };
-      return first;
-    }
-
-    if (first.kind === "autoplay-audio-task") {
-      this.runningTask = { task: first, startedAt: now };
-      return first;
-    }
-
-    return { kind: "noop-task" };
-  }
-}

package/src/state/Dstate.spec.ts

@@ -1,7 +0,0 @@
-import { DState } from "./Dstate";
-
-describe("Prop-utils work", () => {
-    it("isMutation works", () => {
-        expect(DState.isStringMutation({ propName: "", value: 2, kind: "set-number" })).toBe(false);
-    });
-});

package/src/state/Dstate.ts

@@ -1,105 +0,0 @@
-import { Fact } from "../rules/fact";
-import { Condition } from "../rules/condition";
-import { DEvent } from "../events/DEvents";
-import { StateCommand } from "../commands/DCommand";
-
-export namespace DState {
-    interface PropDefinition<TypeName, Type extends string | number> {
-        readonly _type: TypeName;
-        readonly propName: string;
-        readonly propDescription: string;
-        readonly initialValue?: Type;
-        readonly options?: ReadonlyArray<PropValue<Type>>;
-    }
-
-    export type NumericProp = PropDefinition<"number", number>;
-    export type StringProp = PropDefinition<"string", string>;
-
-    export interface fromEventHandler {
-        readonly onEvent: DEvent["kind"];
-        readonly thenExecute: ReadonlyArray<StateCommand>;
-    }
-
-    export interface PropValue<T> {
-        readonly value: T;
-        readonly valueLabel: string;
-    }
-    export type Prop = NumericProp | StringProp;
-
-    export interface SetStringMutation {
-        readonly kind: "set-string";
-        readonly propName: string;
-        readonly value: string;
-    }
-
-    export interface IncrementNumberMutation {
-        readonly kind: "increment-number";
-        readonly propName: string;
-        readonly stepSize: number;
-        readonly ifNotExistThenSetTo: number;
-    }
-    export interface DecrementNumberMutation {
-        readonly kind: "decrement-number";
-        readonly propName: string;
-        readonly stepSize: number;
-        readonly ifNotExistThenSetTo: number;
-    }
-
-    export interface SetNumberMutation {
-        readonly kind: "set-number";
-        readonly propName: string;
-        readonly value: number;
-    }
-    export type NumberMutations = IncrementNumberMutation | DecrementNumberMutation | SetNumberMutation;
-
-    export type StateMutation = SetStringMutation | NumberMutations;
-
-    export const isNumberMutation = (mutations: StateMutation): mutations is NumberMutations => {
-        if (!mutations) {
-            return false;
-        }
-
-        return (
-            mutations.kind === "set-number" ||
-            mutations.kind === "decrement-number" ||
-            mutations.kind === "increment-number"
-        );
-    };
-
-    export const isStringMutation = (mutation: StateMutation): mutation is SetStringMutation => {
-        return mutation && mutation.kind === "set-string";
-    };
-
-    export interface StateQuery {
-        readonly name: string;
-        readonly condition: Condition;
-    }
-
-    export interface StateQueryResult {
-        readonly queryName: string;
-        readonly prev: boolean;
-        readonly curr: boolean;
-    }
-
-    export const numericPropToFact = (prop: NumericProp, value: number) => {
-        const fact: Fact.Numeric = {
-            kind: "numeric-fact",
-            referenceId: prop.propName,
-            referenceLabel: prop.propDescription ?? " [STATE_PROPERTY] : " + prop.propName,
-            value,
-            label: " [VALUE] : " + value,
-        };
-        return fact;
-    };
-
-    export const stringPropToFact = (prop: StringProp, value: string) => {
-        const fact: Fact.String = {
-            kind: "string-fact",
-            referenceId: prop.propName,
-            referenceLabel: " [STATE_PROPERTY] : " + prop.propName,
-            value,
-            label: " [VALUE] : " + value,
-        };
-        return fact;
-    };
-}

package/src/state/boolean-property.ts

@@ -1,69 +0,0 @@
-import { DState } from "./Dstate";
-import { Condition } from "../rules/condition";
-import { StateCommand } from "../commands/DCommand";
-
-export class BooleanStateProperty<PropName extends string> {
-    readonly propName: PropName;
-    private static readonly TRUE = { value: 1, label: "TRUE" };
-    private static readonly FALSE = { value: 0, label: "FALSE" };
-    readonly propDefinition: DState.NumericProp;
-
-    getIsTrueCondition(): Condition.Numeric {
-        return {
-            kind: "numeric-condition",
-            referenceId: this.propName,
-            referenceLabel: this.propName + "[ BOOLEAN ]",
-            valueLabel: BooleanStateProperty.TRUE.label,
-            value: BooleanStateProperty.TRUE.value,
-            operator: "eq",
-        };
-    }
-    getIsFalseCondition(): Condition.Numeric {
-        return {
-            kind: "numeric-condition",
-            referenceId: this.propName,
-            referenceLabel: this.propName + "[ BOOLEAN ]",
-            valueLabel: BooleanStateProperty.FALSE.label,
-            value: BooleanStateProperty.FALSE.value,
-            operator: "eq",
-        };
-    }
-
-    getSetTrueCommand(): StateCommand {
-        return {
-            kind: "STATE_MUTATE_COMMAND",
-            target: "STATE",
-            targetId: "STATE",
-            payload: {
-                mutation: { propName: this.propName, kind: "set-number", value: 1 },
-            },
-        };
-    }
-
-    getSetFalseCommand(): StateCommand {
-        return {
-            kind: "STATE_MUTATE_COMMAND",
-            target: "STATE",
-            targetId: "STATE",
-            payload: {
-                mutation: { propName: this.propName, kind: "set-number", value: 0 },
-            },
-        };
-    }
-
-    constructor(propName: PropName, private readonly initialValue: boolean, description: string) {
-        this.propName = propName;
-        const initial = initialValue ? 1 : 0;
-        const propDescription = description ? description : "No description given";
-        this.propDefinition = {
-            propDescription,
-            propName: propName,
-            initialValue: initial,
-            options: [
-                { value: BooleanStateProperty.FALSE.value, valueLabel: BooleanStateProperty.FALSE.label },
-                { value: BooleanStateProperty.TRUE.value, valueLabel: BooleanStateProperty.TRUE.label },
-            ],
-            _type: "number",
-        };
-    }
-}