refactor folders to move "/state" (IApplicationState) inside "/context" (IApplicationContext)

src/application/Context/State/ApplicationState.ts

@@ -0,0 +1,20 @@
+import { UserFilter } from './Filter/UserFilter';
+import { IUserFilter } from './Filter/IUserFilter';
+import { ApplicationCode } from './Code/ApplicationCode';
+import { UserSelection } from './Selection/UserSelection';
+import { IUserSelection } from './Selection/IUserSelection';
+import { IApplicationState } from './IApplicationState';
+import { IApplication } from '@/domain/IApplication';
+import { IApplicationCode } from './Code/IApplicationCode';
+
+export class ApplicationState implements IApplicationState {
+    public readonly code: IApplicationCode;
+    public readonly selection: IUserSelection;
+    public readonly filter: IUserFilter;
+
+    public constructor(readonly app: IApplication) {
+        this.selection = new UserSelection(app, []);
+        this.code = new ApplicationCode(this.selection, app.scripting);
+        this.filter = new UserFilter(app);
+    }
+}

src/application/Context/State/Code/ApplicationCode.ts

@@ -0,0 +1,39 @@
+import { CodeChangedEvent } from './Event/CodeChangedEvent';
+import { CodePosition } from './Position/CodePosition';
+import { ICodeChangedEvent } from './Event/ICodeChangedEvent';
+import { SelectedScript } from '@/application/Context/State/Selection/SelectedScript';
+import { IUserSelection } from '@/application/Context/State/Selection/IUserSelection';
+import { UserScriptGenerator } from './Generation/UserScriptGenerator';
+import { Signal } from '@/infrastructure/Events/Signal';
+import { IApplicationCode } from './IApplicationCode';
+import { IUserScriptGenerator } from './Generation/IUserScriptGenerator';
+import { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+
+export class ApplicationCode implements IApplicationCode {
+    public readonly changed = new Signal<ICodeChangedEvent>();
+    public current: string;
+
+    private scriptPositions = new Map<SelectedScript, CodePosition>();
+
+    constructor(
+        userSelection: IUserSelection,
+        private readonly scriptingDefinition: IScriptingDefinition,
+        private readonly generator: IUserScriptGenerator = new UserScriptGenerator()) {
+        if (!userSelection) { throw new Error('userSelection is null or undefined'); }
+        if (!scriptingDefinition) { throw new Error('scriptingDefinition is null or undefined'); }
+        if (!generator) { throw new Error('generator is null or undefined'); }
+        this.setCode(userSelection.selectedScripts);
+        userSelection.changed.on((scripts) => {
+            this.setCode(scripts);
+        });
+    }
+
+    private setCode(scripts: ReadonlyArray<SelectedScript>): void {
+        const oldScripts = Array.from(this.scriptPositions.keys());
+        const code = this.generator.buildCode(scripts, this.scriptingDefinition);
+        this.current = code.code;
+        this.scriptPositions = code.scriptPositions;
+        const event = new CodeChangedEvent(code.code, oldScripts, code.scriptPositions);
+        this.changed.notify(event);
+    }
+}

src/application/Context/State/Code/Event/CodeChangedEvent.ts

@@ -0,0 +1,64 @@
+import { ICodeChangedEvent } from './ICodeChangedEvent';
+import { SelectedScript } from '../../Selection/SelectedScript';
+import { IScript } from '@/domain/IScript';
+import { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
+
+export class CodeChangedEvent implements ICodeChangedEvent {
+    public readonly code: string;
+    public readonly addedScripts: ReadonlyArray<IScript>;
+    public readonly removedScripts: ReadonlyArray<IScript>;
+    public readonly changedScripts: ReadonlyArray<IScript>;
+
+    private readonly scripts: Map<IScript, ICodePosition>;
+
+    constructor(
+        code: string,
+        oldScripts: ReadonlyArray<SelectedScript>,
+        scripts: Map<SelectedScript, ICodePosition>) {
+        ensureAllPositionsExist(code, Array.from(scripts.values()));
+        this.code = code;
+        const newScripts = Array.from(scripts.keys());
+        this.addedScripts = selectIfNotExists(newScripts, oldScripts);
+        this.removedScripts = selectIfNotExists(oldScripts, newScripts);
+        this.changedScripts = getChangedScripts(oldScripts, newScripts);
+        this.scripts = new Map<IScript, ICodePosition>();
+        scripts.forEach((position, selection) => {
+            this.scripts.set(selection.script, position);
+        });
+    }
+
+    public isEmpty(): boolean {
+        return this.scripts.size === 0;
+    }
+
+    public getScriptPositionInCode(script: IScript): ICodePosition {
+       return this.scripts.get(script);
+    }
+}
+
+function ensureAllPositionsExist(script: string, positions: ReadonlyArray<ICodePosition>) {
+    const totalLines = script.split(/\r\n|\r|\n/).length;
+    for (const position of positions) {
+        if (position.endLine > totalLines) {
+            throw new Error(`script end line (${position.endLine}) is out of range.` +
+                            `(total code lines: ${totalLines}`);
+        }
+    }
+}
+
+function getChangedScripts(
+    oldScripts: ReadonlyArray<SelectedScript>,
+    newScripts: ReadonlyArray<SelectedScript>): ReadonlyArray<IScript> {
+    return newScripts
+        .filter((newScript) => oldScripts.find((oldScript) => oldScript.id === newScript.id
+                               && oldScript.revert !== newScript.revert ))
+        .map((selection) => selection.script);
+}
+
+function selectIfNotExists(
+    selectableContainer: ReadonlyArray<SelectedScript>,
+    test: ReadonlyArray<SelectedScript>) {
+    return selectableContainer
+        .filter((script) => !test.find((oldScript) => oldScript.id === script.id))
+        .map((selection) => selection.script);
+}

src/application/Context/State/Code/Event/ICodeChangedEvent.ts

@@ -0,0 +1,11 @@
+import { IScript } from '@/domain/IScript';
+import { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
+
+export interface ICodeChangedEvent {
+    readonly code: string;
+    addedScripts: ReadonlyArray<IScript>;
+    removedScripts: ReadonlyArray<IScript>;
+    changedScripts: ReadonlyArray<IScript>;
+    isEmpty(): boolean;
+    getScriptPositionInCode(script: IScript): ICodePosition;
+}

src/application/Context/State/Code/Generation/CodeBuilder.ts

@@ -0,0 +1,65 @@
+import { ICodeBuilder } from './ICodeBuilder';
+
+const NewLine = '\n';
+const TotalFunctionSeparatorChars = 58;
+
+export class CodeBuilder implements ICodeBuilder {
+    private readonly lines = new Array<string>();
+
+    // Returns current line starting from 0 (no lines), or 1 (have single line)
+    public get currentLine(): number {
+        return this.lines.length;
+    }
+
+    public appendLine(code?: string): CodeBuilder {
+        if (!code) {
+            this.lines.push('');
+            return this;
+        }
+        const lines = code.match(/[^\r\n]+/g);
+        for (const line of lines) {
+            this.lines.push(line);
+        }
+        return this;
+    }
+
+    public appendTrailingHyphensCommentLine(
+        totalRepeatHyphens: number = TotalFunctionSeparatorChars): CodeBuilder {
+        return this.appendCommentLine('-'.repeat(totalRepeatHyphens));
+    }
+
+    public appendCommentLine(commentLine?: string): CodeBuilder {
+        this.lines.push(`:: ${commentLine}`);
+        return this;
+    }
+
+    public appendFunction(name: string, code: string): CodeBuilder {
+        if (!name)  { throw new Error('name cannot be empty or null'); }
+        if (!code)  { throw new Error('code cannot be empty or null'); }
+        return this
+            .appendLine()
+            .appendCommentLineWithHyphensAround(name)
+            .appendLine(`echo --- ${name}`)
+            .appendLine(code)
+            .appendTrailingHyphensCommentLine();
+    }
+
+    public appendCommentLineWithHyphensAround(
+        sectionName: string,
+        totalRepeatHyphens: number = TotalFunctionSeparatorChars): CodeBuilder {
+        if (!sectionName)  { throw new Error('sectionName cannot be empty or null'); }
+        if (sectionName.length >= totalRepeatHyphens) {
+            return this.appendCommentLine(sectionName);
+        }
+        const firstHyphens = '-'.repeat(Math.floor((totalRepeatHyphens - sectionName.length) / 2));
+        const secondHyphens = '-'.repeat(Math.ceil((totalRepeatHyphens - sectionName.length) / 2));
+        return this
+            .appendTrailingHyphensCommentLine()
+            .appendCommentLine(firstHyphens + sectionName + secondHyphens)
+            .appendTrailingHyphensCommentLine(TotalFunctionSeparatorChars);
+    }
+
+    public toString(): string {
+        return this.lines.join(NewLine);
+    }
+}

src/application/Context/State/Code/Generation/ICodeBuilder.ts

@@ -0,0 +1,9 @@
+export interface ICodeBuilder {
+    currentLine: number;
+    appendLine(code?: string): ICodeBuilder;
+    appendTrailingHyphensCommentLine(totalRepeatHyphens: number): ICodeBuilder;
+    appendCommentLine(commentLine?: string): ICodeBuilder;
+    appendCommentLineWithHyphensAround(sectionName: string, totalRepeatHyphens: number): ICodeBuilder;
+    appendFunction(name: string, code: string): ICodeBuilder;
+    toString(): string;
+}

src/application/Context/State/Code/Generation/IUserScript.ts

@@ -0,0 +1,7 @@
+import { SelectedScript } from '@/application/Context/State/Selection/SelectedScript';
+import { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
+
+export interface IUserScript {
+    code: string;
+    scriptPositions: Map<SelectedScript, ICodePosition>;
+}

src/application/Context/State/Code/Generation/IUserScriptGenerator.ts

@@ -0,0 +1,9 @@
+import { SelectedScript } from '@/application/Context/State/Selection/SelectedScript';
+import { IUserScript } from './IUserScript';
+import { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+
+export interface IUserScriptGenerator {
+    buildCode(
+        selectedScripts: ReadonlyArray<SelectedScript>,
+        scriptingDefinition: IScriptingDefinition): IUserScript;
+}

src/application/Context/State/Code/Generation/UserScriptGenerator.ts

@@ -0,0 +1,67 @@
+import { SelectedScript } from '@/application/Context/State/Selection/SelectedScript';
+import { IUserScriptGenerator } from './IUserScriptGenerator';
+import { CodeBuilder } from './CodeBuilder';
+import { ICodePosition } from '@/application/Context/State/Code/Position/ICodePosition';
+import { CodePosition } from '../Position/CodePosition';
+import { IUserScript } from './IUserScript';
+import { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import { ICodeBuilder } from './ICodeBuilder';
+
+export class UserScriptGenerator implements IUserScriptGenerator {
+    constructor(private readonly codeBuilderFactory: () => ICodeBuilder = () => new CodeBuilder()) {
+
+    }
+    public buildCode(
+        selectedScripts: ReadonlyArray<SelectedScript>,
+        scriptingDefinition: IScriptingDefinition): IUserScript {
+        if (!selectedScripts) { throw new Error('undefined scripts'); }
+        if (!scriptingDefinition) { throw new Error('undefined definition'); }
+        let scriptPositions = new Map<SelectedScript, ICodePosition>();
+        if (!selectedScripts.length) {
+            return { code: '', scriptPositions };
+        }
+        let builder = this.codeBuilderFactory();
+        builder = initializeCode(scriptingDefinition.startCode, builder);
+        for (const selection of selectedScripts) {
+            scriptPositions = appendSelection(selection, scriptPositions, builder);
+        }
+        const code = finalizeCode(builder, scriptingDefinition.endCode);
+        return { code, scriptPositions };
+    }
+}
+
+function initializeCode(startCode: string, builder: ICodeBuilder): ICodeBuilder {
+    if (!startCode) {
+        return builder;
+    }
+    return builder
+        .appendLine(startCode)
+        .appendLine();
+}
+
+function finalizeCode(builder: ICodeBuilder, endCode: string): string {
+    if (!endCode) {
+        return builder.toString();
+    }
+    return builder.appendLine()
+        .appendLine(endCode)
+        .toString();
+}
+
+function appendSelection(
+    selection: SelectedScript,
+    scriptPositions: Map<SelectedScript, ICodePosition>,
+    builder: ICodeBuilder): Map<SelectedScript, ICodePosition> {
+    const startPosition = builder.currentLine + 1;
+    appendCode(selection, builder);
+    const endPosition = builder.currentLine - 1;
+    builder.appendLine();
+    scriptPositions.set(selection, new CodePosition(startPosition, endPosition));
+    return scriptPositions;
+}
+
+function appendCode(selection: SelectedScript, builder: ICodeBuilder) {
+    const name = selection.revert ? `${selection.script.name} (revert)` : selection.script.name;
+    const scriptCode = selection.revert ? selection.script.code.revert : selection.script.code.execute;
+    builder.appendFunction(name, scriptCode);
+}

src/application/Context/State/Code/IApplicationCode.ts

@@ -0,0 +1,7 @@
+import { ICodeChangedEvent } from './Event/ICodeChangedEvent';
+import { ISignal } from '@/infrastructure/Events/ISignal';
+
+export interface IApplicationCode {
+    readonly changed: ISignal<ICodeChangedEvent>;
+    readonly current: string;
+}

src/application/Context/State/Code/Position/CodePosition.ts

@@ -0,0 +1,24 @@
+import { ICodePosition } from './ICodePosition';
+export class CodePosition implements ICodePosition {
+
+    public get totalLines(): number {
+        return this.endLine - this.startLine;
+    }
+
+    constructor(
+        public readonly startLine: number,
+        public readonly endLine: number) {
+        if (startLine < 0) {
+            throw new Error('Code cannot start in a negative line');
+        }
+        if (endLine < 0) {
+            throw new Error('Code cannot end in a negative line');
+        }
+        if (endLine === startLine) {
+            throw new Error('Empty code');
+        }
+        if (endLine < startLine) {
+            throw new Error('End line cannot be less than start line');
+        }
+    }
+}

src/application/Context/State/Code/Position/ICodePosition.ts

@@ -0,0 +1,5 @@
+export interface ICodePosition {
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly totalLines: number;
+}

src/application/Context/State/Filter/FilterResult.ts

@@ -0,0 +1,18 @@
+import { IFilterResult } from './IFilterResult';
+import { IScript } from '@/domain/IScript';
+import { ICategory } from '@/domain/ICategory';
+
+export class FilterResult implements IFilterResult {
+    constructor(
+        public readonly scriptMatches: ReadonlyArray<IScript>,
+        public readonly categoryMatches: ReadonlyArray<ICategory>,
+        public readonly query: string) {
+        if (!query) { throw new Error('Query is empty or undefined'); }
+        if (!scriptMatches) { throw new Error('Script matches is undefined'); }
+        if (!categoryMatches) { throw new Error('Category matches is undefined'); }
+    }
+    public hasAnyMatches(): boolean {
+        return this.scriptMatches.length > 0
+         || this.categoryMatches.length > 0;
+    }
+}

src/application/Context/State/Filter/IFilterResult.ts

@@ -0,0 +1,8 @@
+import { IScript, ICategory } from '@/domain/ICategory';
+
+export interface IFilterResult {
+    readonly categoryMatches: ReadonlyArray<ICategory>;
+    readonly scriptMatches: ReadonlyArray<IScript>;
+    readonly query: string;
+    hasAnyMatches(): boolean;
+}

src/application/Context/State/Filter/IUserFilter.ts

@@ -0,0 +1,10 @@
+import { IFilterResult } from './IFilterResult';
+import { ISignal } from '@/infrastructure/Events/Signal';
+
+export interface IUserFilter {
+    readonly currentFilter: IFilterResult | undefined;
+    readonly filtered: ISignal<IFilterResult>;
+    readonly filterRemoved: ISignal<void>;
+    setFilter(filter: string): void;
+    removeFilter(): void;
+}

src/application/Context/State/Filter/UserFilter.ts

@@ -0,0 +1,52 @@
+import { IScript } from '@/domain/IScript';
+import { FilterResult } from './FilterResult';
+import { IFilterResult } from './IFilterResult';
+import { IApplication } from '@/domain/IApplication';
+import { IUserFilter } from './IUserFilter';
+import { Signal } from '@/infrastructure/Events/Signal';
+
+export class UserFilter implements IUserFilter {
+    public readonly filtered = new Signal<IFilterResult>();
+    public readonly filterRemoved = new Signal<void>();
+    public currentFilter: IFilterResult | undefined;
+
+    constructor(private application: IApplication) {
+
+    }
+
+    public setFilter(filter: string): void {
+        if (!filter) {
+            throw new Error('Filter must be defined and not empty. Use removeFilter() to remove the filter');
+        }
+        const filterLowercase = filter.toLocaleLowerCase();
+        const filteredScripts = this.application.getAllScripts().filter(
+            (script) => isScriptAMatch(script, filterLowercase));
+        const filteredCategories = this.application.getAllCategories().filter(
+            (category) => category.name.toLowerCase().includes(filterLowercase));
+        const matches = new FilterResult(
+            filteredScripts,
+            filteredCategories,
+            filter,
+        );
+        this.currentFilter = matches;
+        this.filtered.notify(matches);
+    }
+
+    public removeFilter(): void {
+        this.currentFilter = undefined;
+        this.filterRemoved.notify();
+    }
+}
+
+function isScriptAMatch(script: IScript, filterLowercase: string) {
+    if (script.name.toLowerCase().includes(filterLowercase)) {
+        return true;
+    }
+    if (script.code.execute.toLowerCase().includes(filterLowercase)) {
+        return true;
+    }
+    if (script.code.revert) {
+        return script.code.revert.toLowerCase().includes(filterLowercase);
+    }
+    return false;
+}

src/application/Context/State/IApplicationState.ts

@@ -0,0 +1,10 @@
+import { IUserFilter } from './Filter/IUserFilter';
+import { IUserSelection } from './Selection/IUserSelection';
+import { IApplicationCode } from './Code/IApplicationCode';
+export { IUserSelection, IApplicationCode, IUserFilter };
+
+export interface IApplicationState {
+    readonly code: IApplicationCode;
+    readonly filter: IUserFilter;
+    readonly selection: IUserSelection;
+}

src/application/Context/State/Selection/IUserSelection.ts

@@ -0,0 +1,21 @@
+import { SelectedScript } from './SelectedScript';
+import { ISignal } from '@/infrastructure/Events/Signal';
+import { IScript } from '@/domain/IScript';
+import { ICategory } from '@/domain/ICategory';
+
+export interface IUserSelection {
+    readonly changed: ISignal<ReadonlyArray<SelectedScript>>;
+    readonly selectedScripts: ReadonlyArray<SelectedScript>;
+    readonly totalSelected: number;
+    areAllSelected(category: ICategory): boolean;
+    isAnySelected(category: ICategory): boolean;
+    removeAllInCategory(categoryId: number): void;
+    addOrUpdateAllInCategory(categoryId: number, revert: boolean): void;
+    addSelectedScript(scriptId: string, revert: boolean): void;
+    addOrUpdateSelectedScript(scriptId: string, revert: boolean): void;
+    removeSelectedScript(scriptId: string): void;
+    selectOnly(scripts: ReadonlyArray<IScript>): void;
+    isSelected(scriptId: string): boolean;
+    selectAll(): void;
+    deselectAll(): void;
+}

src/application/Context/State/Selection/SelectedScript.ts

@@ -0,0 +1,14 @@
+import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
+import { IScript } from '@/domain/IScript';
+
+export class SelectedScript extends BaseEntity<string> {
+    constructor(
+        public readonly script: IScript,
+        public readonly revert: boolean,
+        ) {
+        super(script.id);
+        if (revert && !script.canRevert()) {
+            throw new Error('cannot revert an irreversible script');
+        }
+    }
+}

src/application/Context/State/Selection/UserSelection.ts

@@ -0,0 +1,144 @@
+import { SelectedScript } from './SelectedScript';
+import { IApplication, ICategory } from '@/domain/IApplication';
+import { IUserSelection } from './IUserSelection';
+import { InMemoryRepository } from '@/infrastructure/Repository/InMemoryRepository';
+import { IScript } from '@/domain/IScript';
+import { Signal } from '@/infrastructure/Events/Signal';
+import { IRepository } from '@/infrastructure/Repository/IRepository';
+
+export class UserSelection implements IUserSelection {
+    public readonly changed = new Signal<ReadonlyArray<SelectedScript>>();
+    private readonly scripts: IRepository<string, SelectedScript>;
+
+    constructor(
+        private readonly app: IApplication,
+        selectedScripts: ReadonlyArray<SelectedScript>) {
+        this.scripts =  new InMemoryRepository<string, SelectedScript>();
+        if (selectedScripts && selectedScripts.length > 0) {
+            for (const script of selectedScripts) {
+                this.scripts.addItem(script);
+            }
+        }
+    }
+
+    public areAllSelected(category: ICategory): boolean {
+        if (this.selectedScripts.length === 0) {
+            return false;
+        }
+        const scripts = category.getAllScriptsRecursively();
+        if (this.selectedScripts.length < scripts.length) {
+            return false;
+        }
+        return scripts.every((script) => this.selectedScripts.some((selected) => selected.id === script.id));
+    }
+
+    public isAnySelected(category: ICategory): boolean {
+        if (this.selectedScripts.length === 0) {
+            return false;
+        }
+        return this.selectedScripts.some((s) => category.includes(s.script));
+    }
+
+    public removeAllInCategory(categoryId: number): void {
+        const category = this.app.findCategory(categoryId);
+        const scriptsToRemove = category.getAllScriptsRecursively()
+            .filter((script) => this.scripts.exists(script.id));
+        if (!scriptsToRemove.length) {
+            return;
+        }
+        for (const script of scriptsToRemove) {
+            this.scripts.removeItem(script.id);
+        }
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public addOrUpdateAllInCategory(categoryId: number, revert: boolean = false): void {
+        const category = this.app.findCategory(categoryId);
+        const scriptsToAddOrUpdate = category.getAllScriptsRecursively()
+            .filter((script) =>
+                !this.scripts.exists(script.id)
+                    || this.scripts.getById(script.id).revert !== revert,
+            );
+        if (!scriptsToAddOrUpdate.length) {
+            return;
+        }
+        for (const script of scriptsToAddOrUpdate) {
+            const selectedScript = new SelectedScript(script, revert);
+            this.scripts.addOrUpdateItem(selectedScript);
+        }
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public addSelectedScript(scriptId: string, revert: boolean): void {
+        const script = this.app.findScript(scriptId);
+        if (!script) {
+            throw new Error(`Cannot add (id: ${scriptId}) as it is unknown`);
+        }
+        const selectedScript = new SelectedScript(script, revert);
+        this.scripts.addItem(selectedScript);
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public addOrUpdateSelectedScript(scriptId: string, revert: boolean): void {
+        const script = this.app.findScript(scriptId);
+        const selectedScript = new SelectedScript(script, revert);
+        this.scripts.addOrUpdateItem(selectedScript);
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public removeSelectedScript(scriptId: string): void {
+        this.scripts.removeItem(scriptId);
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public isSelected(scriptId: string): boolean {
+        return this.scripts.exists(scriptId);
+    }
+
+    /** Get users scripts based on his/her selections */
+    public get selectedScripts(): ReadonlyArray<SelectedScript> {
+        return this.scripts.getItems();
+    }
+
+    public get totalSelected(): number {
+        return this.scripts.getItems().length;
+    }
+
+    public selectAll(): void {
+        for (const script of this.app.getAllScripts()) {
+            if (!this.scripts.exists(script.id)) {
+                const selection = new SelectedScript(script, false);
+                this.scripts.addItem(selection);
+            }
+        }
+        this.changed.notify(this.scripts.getItems());
+    }
+
+    public deselectAll(): void {
+        const selectedScriptIds = this.scripts.getItems().map((script) => script.id);
+        for (const scriptId of selectedScriptIds) {
+            this.scripts.removeItem(scriptId);
+        }
+        this.changed.notify([]);
+    }
+
+    public selectOnly(scripts: readonly IScript[]): void {
+        if (!scripts || scripts.length === 0) {
+            throw new Error('Scripts are empty. Use deselectAll() if you want to deselect everything');
+        }
+        // Unselect from selected scripts
+        if (this.scripts.length !== 0) {
+            this.scripts.getItems()
+                .filter((existing) => !scripts.some((script) => existing.id === script.id))
+                .map((script) => script.id)
+                .forEach((scriptId) => this.scripts.removeItem(scriptId));
+        }
+        // Select from unselected scripts
+        const unselectedScripts = scripts.filter((script) => !this.scripts.exists(script.id));
+        for (const toSelect of unselectedScripts) {
+            const selection = new SelectedScript(toSelect, false);
+            this.scripts.addItem(selection);
+        }
+        this.changed.notify(this.scripts.getItems());
+    }
+}