@sprucelabs/spruce-cli 19.0.0 → 19.1.0

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/List.vc.js

@@ -0,0 +1,270 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SchemaError } from '@sprucelabs/schema';
+import SpruceError from '../../errors/SpruceError.js';
+import AbstractViewController from '../Abstract.vc.js';
+import listUtil from './list.utility.js';
+import ListRowViewController from './ListRow.vc.js';
+export default class ListViewController extends AbstractViewController {
+    constructor(options) {
+        var _a, _b, _c;
+        super(options);
+        this.model = {
+            rows: [],
+        };
+        this._rowVcs = [];
+        if (options.rows) {
+            for (const row of options.rows) {
+                const matches = (_b = (_a = options.rows) === null || _a === void 0 ? void 0 : _a.filter((r) => r.id === row.id)) !== null && _b !== void 0 ? _b : [];
+                if (matches.length > 1) {
+                    throw new SpruceError({
+                        code: 'DUPLICATE_ROW_ID',
+                        rowId: row.id,
+                    });
+                }
+            }
+        }
+        this.model = Object.assign(Object.assign({}, options), { rows: (_c = options.rows) !== null && _c !== void 0 ? _c : [] });
+    }
+    getRows() {
+        return this.model.rows;
+    }
+    addRows(rows) {
+        for (const row of rows) {
+            this.addRow(row);
+        }
+    }
+    setColumnWidths(widths) {
+        this.model.columnWidths = [...widths];
+        this.triggerRender();
+    }
+    addRow(row) {
+        if (!row) {
+            throw new SchemaError({
+                code: 'MISSING_PARAMETERS',
+                parameters: ['cells'],
+            });
+        }
+        if (!Array.isArray(row.cells)) {
+            throw new SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['cells'],
+                friendlyMessage: `Your row needs some cells.`,
+            });
+        }
+        if (row.id && this.doesRowExist(row.id)) {
+            throw new SpruceError({
+                code: 'DUPLICATE_ROW_ID',
+                rowId: row.id,
+            });
+        }
+        if (row.atIndex) {
+            this.model.rows.splice(row.atIndex, 0, Object.assign({}, row));
+        }
+        else {
+            this.model.rows.push(Object.assign({}, row));
+        }
+        this._rowVcs = [];
+        this.triggerRender();
+    }
+    getRowVc(row) {
+        if (typeof row === 'string') {
+            return this.getRowVcById(row);
+        }
+        if (!this._rowVcs[row]) {
+            this.assertValidRowIdx(row);
+            const id = this.model.rows[row].id;
+            this._rowVcs[row] = new ListRowViewController(Object.assign({ setIsSelected: (is) => {
+                    const idx = this.getIdxForId(id);
+                    this.model.rows[idx].isSelected = is;
+                }, setIsEnabled: (is) => {
+                    const idx = this.getIdxForId(id);
+                    this.model.rows[idx].isEnabled = is;
+                }, setValue: (name, value) => __awaiter(this, void 0, void 0, function* () {
+                    const idx = this.getIdxForId(id);
+                    yield this.setValue({ rowIdx: idx, name, value });
+                }), getValues: () => {
+                    const idx = this.getIdxForId(id);
+                    return this.getRowValues(idx);
+                }, deleteRow: () => {
+                    const idx = this.getIdxForId(id);
+                    this.deleteRow(idx);
+                }, getModel: () => {
+                    const idx = this.getIdxForId(id);
+                    return this.model.rows[idx];
+                }, isLastRow: row == this.getTotalRows() - 1 }, this.model.rows[row]));
+        }
+        return this._rowVcs[row];
+    }
+    assertValidRowIdx(rowIdx) {
+        var _a;
+        if (!((_a = this.model.rows[rowIdx]) === null || _a === void 0 ? void 0 : _a.cells)) {
+            throw new SchemaError({
+                code: 'INVALID_PARAMETERS',
+                friendlyMessage: `Could not get view controller for row ${rowIdx} because it does not exist.`,
+                parameters: ['rowIdx'],
+            });
+        }
+    }
+    getTotalRows() {
+        return this.model.rows.length;
+    }
+    getRowValues(rowIdx) {
+        const row = this.model.rows[rowIdx];
+        const values = {};
+        for (const cell of row.cells) {
+            const input = listUtil.getInputFromCell(cell);
+            if (input) {
+                values[input.name] = input.value;
+                values.rowId = row.id;
+            }
+        }
+        return values;
+    }
+    setValue(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { rowIdx, name, value } = options;
+            for (const cell of this.model.rows[rowIdx].cells) {
+                const input = listUtil.getInputFromCell(cell);
+                const isField = (input === null || input === void 0 ? void 0 : input.name) === name;
+                if (isField && input.value === value) {
+                    return;
+                }
+                if (isField) {
+                    const originalValue = input.value;
+                    input.value = value;
+                    //@ts-ignore
+                    const onChangeResponse = yield ((_a = input.onChange) === null || _a === void 0 ? void 0 : _a.call(input, value));
+                    if (onChangeResponse === false) {
+                        input.value = originalValue;
+                    }
+                    return;
+                }
+            }
+            throw new SchemaError({
+                code: 'INVALID_PARAMETERS',
+                friendlyMessage: `A field named \`${name}\` does not exist in row ${rowIdx}`,
+                parameters: ['fieldName'],
+            });
+        });
+    }
+    getRowVcs() {
+        return this.model.rows.map((_, idx) => this.getRowVc(idx));
+    }
+    getValues() {
+        let values = [];
+        for (const rowVc of this.getRowVcs()) {
+            values.push(rowVc.getValues());
+        }
+        return values;
+    }
+    setRows(rows) {
+        this.model.rows = rows;
+        this._rowVcs = [];
+        this.triggerRender();
+    }
+    deleteRow(rowIdx) {
+        if (typeof rowIdx === 'string') {
+            this.deleteRowById(rowIdx);
+        }
+        else {
+            this.assertValidRowIdx(rowIdx);
+            this.model.rows.splice(rowIdx, 1);
+            this._rowVcs = [];
+            this.triggerRender();
+        }
+    }
+    getRowVcById(id) {
+        const idx = this.getIdxForId(id);
+        if (idx === -1) {
+            throw new SchemaError({
+                code: 'INVALID_PARAMETERS',
+                friendlyMessage: `Can't find a row with the id \`${id}\`.`,
+                parameters: ['rowId'],
+            });
+        }
+        return this.getRowVc(idx);
+    }
+    getIdxForId(id) {
+        return this.model.rows.findIndex((r) => r.id === id);
+    }
+    /**
+     * @deprecated Use upsertRow() instead.
+     */
+    upsertRowById(id, row) {
+        return this.upsertRow(id, row);
+    }
+    upsertRow(id, row) {
+        const idx = this.getIdxForId(id);
+        if (idx === -1) {
+            this.addRow(Object.assign({ id }, row));
+        }
+        else {
+            this.model.rows[idx] = Object.assign({ id }, row);
+            this._rowVcs = [];
+            this.triggerRender();
+        }
+    }
+    doesRowExist(id) {
+        const model = this.model;
+        const match = this.doesRowIdExistInModel(model, id);
+        return !!match;
+    }
+    /**
+     * @deprecated doesIdExist() -> doesRowExist
+     */
+    doesIdExist(id) {
+        return this.doesRowExist(id);
+    }
+    doesRowIdExistInModel(model, id) {
+        return model.rows.find((r) => r.id === id);
+    }
+    deleteRowById(id) {
+        const vc = this.getRowVc(id);
+        vc.delete();
+    }
+    getSelectedRows() {
+        var _a;
+        const selected = [];
+        for (const rowVc of this.getRowVcs()) {
+            if (rowVc.getIsSelected()) {
+                selected.push((_a = rowVc.getId()) !== null && _a !== void 0 ? _a : 0);
+            }
+        }
+        return selected;
+    }
+    selectRow(id) {
+        this.getRowVc(id).setIsSelected(true);
+    }
+    deselectRow(id) {
+        this.getRowVc(id).setIsSelected(false);
+    }
+    isRowSelected(row) {
+        const rowVc = this.getRowVc(row);
+        return rowVc.getIsSelected();
+    }
+    setSelectedRows(rows) {
+        for (const selected of this.getSelectedRows()) {
+            this.getRowVc(selected).setIsSelected(false);
+        }
+        for (const row of rows) {
+            this.getRowVc(row).setIsSelected(true);
+        }
+    }
+    deleteAllRows() {
+        this.model.rows = [];
+        this.triggerRender();
+        this._rowVcs = [];
+    }
+    render() {
+        return Object.assign(Object.assign({}, this.model), { controller: this, rows: this.getRowVcs().map((vc) => vc.render()) });
+    }
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/ListCell.vc.d.ts

@@ -0,0 +1,21 @@
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas';
+import { ViewController } from '../../types/heartwood.types';
+type Model = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListCell;
+type Cell = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListCell;
+type SetValueHandler = (name: string, value: any) => Promise<void>;
+interface CellOptions {
+    setValue: SetValueHandler;
+    getViewModel: () => Cell;
+}
+export default class ListCellViewController implements ViewController<Model> {
+    private get model();
+    private setValueHandler;
+    private getViewModelHandler;
+    constructor(options: Cell & CellOptions);
+    triggerRender(): void;
+    setValue(name: string, value: any): Promise<void>;
+    getIsDeleted(): boolean;
+    hasInput(name: string): boolean;
+    render(): Model;
+}
+export {};

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/ListCell.vc.js

@@ -0,0 +1,70 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import SpruceError from '../../errors/SpruceError.js';
+import listUtil from './list.utility.js';
+export default class ListCellViewController {
+    get model() {
+        return this.getViewModelHandler();
+    }
+    constructor(options) {
+        const { setValue: setValueHandler, getViewModel } = options;
+        this.setValueHandler = setValueHandler;
+        this.getViewModelHandler = getViewModel;
+    }
+    triggerRender() { }
+    setValue(name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setValueHandler(name, value);
+            this.triggerRender();
+        });
+    }
+    getIsDeleted() {
+        return !this.model;
+    }
+    hasInput(name) {
+        return !!listUtil.getInputFromCell(this.model, name);
+    }
+    render() {
+        const model = __rest(this.model, []);
+        if (this.getIsDeleted()) {
+            throw new SpruceError({ code: 'CELL_DELETED' });
+        }
+        const keys = Object.keys(model)
+            .map((key) => {
+            //@ts-ignore
+            if (!key.endsWith('Input') || !this.model[key]) {
+                return false;
+            }
+            return {
+                name: key,
+                //@ts-ignore
+                input: this.model[key],
+            };
+        })
+            .filter((f) => !!f);
+        for (const item of keys !== null && keys !== void 0 ? keys : []) {
+            const { name, input } = item;
+            //@ts-ignore
+            model[name] = Object.assign(Object.assign({}, input), { setValue: this.setValue.bind(this) });
+        }
+        return Object.assign(Object.assign({}, model), { controller: this });
+    }
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/ListRow.vc.d.ts

@@ -0,0 +1,41 @@
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas';
+import { ListRow, RowValues, ViewController } from '../../types/heartwood.types';
+import ListCellViewController from './ListCell.vc';
+export default class ListRowViewController implements ViewController<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListRow> {
+    private cellVcs;
+    private get model();
+    private setValueHandler;
+    private getValuesHandler;
+    private deleteRowHandler;
+    private _isLastRow;
+    private setIsSelectedHandler;
+    private setIsEnabledHandler;
+    private getModelHandler;
+    private id;
+    constructor(options: ListRow & {
+        setValue: (name: string, value: any) => void | Promise<void>;
+        getValues: () => Record<string, any>;
+        deleteRow: () => void;
+        setIsSelected: (isSelected: boolean) => void;
+        setIsEnabled: (isEnabled: boolean) => void;
+        getModel: () => ListRow;
+        isLastRow: boolean;
+        id: string;
+    });
+    triggerRender(): void;
+    setValue(name: string, value: any): Promise<void>;
+    private _setValue;
+    hasInput(name: string): boolean;
+    getValues(): RowValues;
+    getValue(fieldName: string): any;
+    isLastRow(): boolean;
+    delete(): void;
+    getId(): string;
+    getIsSelected(): boolean;
+    setIsEnabled(isEnabled: boolean): void;
+    getIsEnabled(): boolean;
+    setIsSelected(isSelected: boolean): void;
+    getIsDeleted(): boolean;
+    getCellVc(idx: number): ListCellViewController;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListRow;
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/ListRow.vc.js

@@ -0,0 +1,111 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SchemaError } from '@sprucelabs/schema';
+import SpruceError from '../../errors/SpruceError.js';
+import listUtil from './list.utility.js';
+import ListCellViewController from './ListCell.vc.js';
+export default class ListRowViewController {
+    get model() {
+        return this.getModelHandler();
+    }
+    constructor(options) {
+        this.cellVcs = [];
+        const { setValue, getValues, deleteRow, setIsSelected, isLastRow, getModel, setIsEnabled, id, } = options;
+        this.getModelHandler = getModel;
+        this.id = id;
+        this.setValueHandler = setValue;
+        this.getValuesHandler = getValues;
+        this.deleteRowHandler = deleteRow;
+        this.setIsSelectedHandler = setIsSelected;
+        this.setIsEnabledHandler = setIsEnabled;
+        this._isLastRow = isLastRow;
+    }
+    triggerRender() { }
+    setValue(name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._setValue(name, value);
+            this.triggerRender();
+        });
+    }
+    _setValue(name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setValueHandler(name, value);
+        });
+    }
+    hasInput(name) {
+        return this.model.cells.reduce((hasInput, cell) => {
+            return hasInput || !!listUtil.getInputFromCell(cell, name);
+        }, false);
+    }
+    getValues() {
+        return this.getValuesHandler();
+    }
+    getValue(fieldName) {
+        const values = this.getValues();
+        if (fieldName in values) {
+            return values[fieldName];
+        }
+        throw new SchemaError({
+            code: 'INVALID_PARAMETERS',
+            parameters: ['fieldName'],
+            friendlyMessage: `I could not find an input named '${fieldName}' in row '${this.getId()}'!`,
+        });
+    }
+    isLastRow() {
+        return this._isLastRow;
+    }
+    delete() {
+        this.deleteRowHandler();
+    }
+    getId() {
+        return this.model.id;
+    }
+    getIsSelected() {
+        var _a;
+        return (_a = this.model.isSelected) !== null && _a !== void 0 ? _a : false;
+    }
+    setIsEnabled(isEnabled) {
+        this.setIsEnabledHandler(isEnabled);
+        this.triggerRender();
+    }
+    getIsEnabled() {
+        return this.model.isEnabled !== false;
+    }
+    setIsSelected(isSelected) {
+        this.setIsSelectedHandler(isSelected);
+        this.triggerRender();
+    }
+    getIsDeleted() {
+        return !this.getModelHandler();
+    }
+    getCellVc(idx) {
+        if (!this.cellVcs[idx]) {
+            const cell = this.model.cells[idx];
+            if (!cell) {
+                throw new SchemaError({
+                    code: 'INVALID_PARAMETERS',
+                    parameters: ['cellIdx'],
+                });
+            }
+            this.cellVcs[idx] = new ListCellViewController({
+                getViewModel: () => { var _a; return (_a = this.model) === null || _a === void 0 ? void 0 : _a.cells[idx]; },
+                setValue: this._setValue.bind(this),
+            });
+        }
+        return this.cellVcs[idx];
+    }
+    render() {
+        if (this.getIsDeleted()) {
+            throw new SpruceError({ code: 'ROW_DELETED', row: this.id });
+        }
+        const model = this.model;
+        return Object.assign(Object.assign({}, model), { controller: this, cells: model.cells.map((_cell, idx) => (Object.assign({}, this.getCellVc(idx).render()))) });
+    }
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/list.utility.d.ts

@@ -0,0 +1,5 @@
+import { ListCell } from '../../types/heartwood.types';
+declare const listUtil: {
+    getInputFromCell(cell: ListCell, name?: string): import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListRatingsInput | import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListToggleInput | import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListSelectInput | import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListDateInput | import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListTextInput | null | undefined;
+};
+export default listUtil;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/list/list.utility.js

@@ -0,0 +1,14 @@
+const inputFields = [
+    'textInput',
+    'selectInput',
+    'toggleInput',
+    'ratingsInput',
+    'checkboxInput',
+    'dateInput',
+];
+const listUtil = {
+    getInputFromCell(cell, name) {
+        return cell[inputFields.find((n) => { var _a; return !!cell[n] && (!name || ((_a = cell[n]) === null || _a === void 0 ? void 0 : _a.name) === name); })];
+    },
+};
+export default listUtil;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/reporting/Progress.vc.d.ts

@@ -0,0 +1,14 @@
+import { SpruceSchemas, ViewControllerOptions } from '../..';
+import AbstractViewController from '../Abstract.vc';
+type Progress = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Progress;
+export type ProgressViewControllerOptions = Progress;
+export default class ProgressViewController extends AbstractViewController<Progress> {
+    private model;
+    constructor(options: ViewControllerOptions & Progress);
+    private assertValidPercentComplete;
+    setPercentComplete(percentComplete: number): void;
+    setTitle(title: string): void;
+    getPercentComplete(): number | null | undefined;
+    render(): Progress;
+}
+export {};

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/reporting/Progress.vc.js

@@ -0,0 +1,38 @@
+import { SchemaError } from '@sprucelabs/schema';
+import removeUniversalViewOptions from '../../utilities/removeUniversalViewOptions.js';
+import AbstractViewController from '../Abstract.vc.js';
+export default class ProgressViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        const percentComplete = options.percentComplete;
+        this.assertValidPercentComplete(percentComplete);
+        this.model = Object.assign({}, removeUniversalViewOptions(options));
+    }
+    assertValidPercentComplete(percentComplete) {
+        if (typeof percentComplete == 'number' &&
+            (percentComplete < 0 || percentComplete > 1)) {
+            throw new SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['percentComplete'],
+                friendlyMessage: 'percentComplete must be a number between 0 and 1',
+            });
+        }
+    }
+    setPercentComplete(percentComplete) {
+        this.assertValidPercentComplete(percentComplete);
+        this.model.percentComplete = percentComplete;
+        this.triggerRender();
+    }
+    setTitle(title) {
+        this.model.title = title;
+        this.triggerRender();
+    }
+    getPercentComplete() {
+        return this.model.percentComplete;
+    }
+    render() {
+        return Object.assign({ 
+            //@ts-ignore
+            controller: this }, this.model);
+    }
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/reporting/Stats.vc.d.ts

@@ -0,0 +1,12 @@
+import { SpruceSchemas } from "./../../.spruce/schemas/schemas.types";
+import { ViewControllerOptions } from '../../types/heartwood.types';
+import AbstractViewController from '../Abstract.vc';
+type Stats = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Stats;
+export type StatsViewControllerOptions = Stats;
+export default class StatsViewController extends AbstractViewController<Stats> {
+    private model;
+    constructor(options: ViewControllerOptions & StatsViewControllerOptions);
+    setValue(idx: number, value: number): void;
+    render(): Stats;
+}
+export {};

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/viewControllers/reporting/Stats.vc.js

@@ -0,0 +1,27 @@
+import { assertOptions, SchemaError } from '@sprucelabs/schema';
+import AbstractViewController from '../Abstract.vc.js';
+export default class StatsViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        assertOptions(options, ['stats']);
+        this.model = Object.assign({ shouldFormatValues: true }, options);
+    }
+    setValue(idx, value) {
+        if (idx < 0 || idx > 2) {
+            throw new SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['idx'],
+                friendlyMessage: 'You can only set values on stats at index 0, 1, or 2.',
+            });
+        }
+        if (!this.model.stats[idx]) {
+            this.model.stats[idx] = {};
+        }
+        this.model.stats[idx].value = value;
+        this.triggerRender();
+    }
+    render() {
+        //@ts-ignore
+        return Object.assign(Object.assign({}, this.model), { controller: this });
+    }
+}