@sprucelabs/spruce-cli 19.0.0 → 19.1.0

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/formBuilder/FormBuilderCard.vc.js

@@ -0,0 +1,325 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const buildForm_1 = __importDefault(require("../../builders/buildForm"));
+const normalizeFieldNames_utility_1 = __importDefault(require("../../utilities/normalizeFieldNames.utility"));
+const render_utility_1 = __importDefault(require("../../utilities/render.utility"));
+const Abstract_vc_1 = __importDefault(require("../Abstract.vc"));
+const EditFormBuilderFieldCard_vc_1 = require("./EditFormBuilderFieldCard.vc");
+const EditFormBuilderSectionCard_vc_1 = __importDefault(require("./EditFormBuilderSectionCard.vc"));
+const FormBuilderPage_vc_1 = require("./FormBuilderPage.vc");
+const ManagePageTitlesCard_vc_1 = __importDefault(require("./ManagePageTitlesCard.vc"));
+class FormBuilderCardViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        var _a;
+        super(options);
+        //@ts-ignore
+        this.__isFormBuilder = true;
+        this.footerOverride = options.footer;
+        this.shouldAllowEditing = (_a = options.shouldAllowEditing) !== null && _a !== void 0 ? _a : true;
+        this.swipeVc = this.Controller('swipeCard', {
+            id: options.id,
+            isBusy: options.isBusy,
+            header: Object.assign({ title: 'Building your form' }, options.header),
+            slides: [this.buildSlideForNewPage()],
+            footer: this.buildFooter(),
+        });
+        spruce_skill_utils_1.functionDelegationUtil.delegateFunctionCalls(this, this.swipeVc);
+        this.swipeVc.triggerRender = () => {
+            this.triggerRender();
+        };
+        this.mixinControllers({
+            //@ts-ignore
+            editFormBuilderSection: EditFormBuilderSectionCard_vc_1.default,
+            //@ts-ignore
+            managePageTitles: ManagePageTitlesCard_vc_1.default,
+            //@ts-ignore
+            editFormBuilderField: EditFormBuilderFieldCard_vc_1.EditFormBuilderFieldCardViewController,
+        });
+    }
+    buildFooter() {
+        if (this.footerOverride) {
+            return this.footerOverride;
+        }
+        const buttons = [
+            { label: 'Add page', onClick: this.handleClickAddPage.bind(this) },
+        ];
+        if (this.getTotalPages() > 1) {
+            buttons.push({
+                label: 'Remove page',
+                onClick: this.removePresentPage.bind(this),
+            });
+        }
+        return {
+            buttons,
+        };
+    }
+    buildSlideForNewPage(options) {
+        return Object.assign({ title: this.buildNextPageTitle(), form: this.renderNewForm(options) }, options);
+    }
+    renderNewForm(options) {
+        var _a, _b;
+        return this.Controller('form', {
+            shouldShowSubmitControls: false,
+            schema: (_a = options === null || options === void 0 ? void 0 : options.schema) !== null && _a !== void 0 ? _a : {
+                id: `formBuilder${this.getTotalPages() + 1}`,
+                fields: {
+                    field1: this.buildField(0),
+                },
+            },
+            //@ts-ignore
+            sections: (_b = options === null || options === void 0 ? void 0 : options.sections) !== null && _b !== void 0 ? _b : [
+                {
+                    title: 'Section 1',
+                    fields: [{ name: 'field1' }],
+                },
+            ],
+        }).render();
+    }
+    buildField(fieldIdx) {
+        return {
+            type: 'text',
+            label: `Field ${fieldIdx + 1}`,
+        };
+    }
+    buildNextPageTitle() {
+        return `Page ${this.getTotalPages() + 1}`;
+    }
+    getTotalPages() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.swipeVc) === null || _a === void 0 ? void 0 : _a.getSlides()) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+    }
+    setHeaderTitle(title) {
+        this.swipeVc.setHeaderTitle(title);
+    }
+    setHeaderSubtitle(title) {
+        this.swipeVc.setHeaderSubtitle(title);
+    }
+    async addPage(options) {
+        const { atIndex: idx } = options !== null && options !== void 0 ? options : {};
+        if (typeof idx === 'number') {
+            this.swipeVc.addSlideAtIndex(idx, this.buildSlideForNewPage(options));
+        }
+        else {
+            this.swipeVc.addSlide(this.buildSlideForNewPage(options));
+        }
+        this.swipeVc.setFooter(this.buildFooter());
+    }
+    async removePage(idx) {
+        this.swipeVc.removeSlide(idx);
+        this.swipeVc.setFooter(this.buildFooter());
+        await this.swipeVc.jumpToSlide(Math.max(idx - 1, 0));
+    }
+    async removePresentPage() {
+        const idx = this.getPresentPage();
+        await this.removePage(idx);
+    }
+    getPageVc(idx) {
+        var _a, _b;
+        const slide = this.swipeVc.getSlide(idx);
+        const formVc = (_a = slide.form) === null || _a === void 0 ? void 0 : _a.controller;
+        if (!formVc) {
+            throw new Error(`Form not set for page ${idx}`);
+        }
+        return new FormBuilderPage_vc_1.FormBuilderPageViewControllerImpl({
+            formVc,
+            setTitleHandler: (title) => {
+                slide.title = title;
+                this.triggerRender();
+            },
+            title: (_b = slide.title) !== null && _b !== void 0 ? _b : '**MISSING**',
+            index: idx,
+            fieldBuilder: this.buildField.bind(this),
+            schema: formVc.getSchema(),
+        });
+    }
+    getPresentPage() {
+        return this.swipeVc.getPresentSlide();
+    }
+    getPresentPageVc() {
+        return this.getPageVc(this.getPresentPage());
+    }
+    async jumpToPage(idx) {
+        await this.swipeVc.jumpToSlide(idx);
+    }
+    getPageVcs() {
+        var _a, _b;
+        return ((_b = (_a = this.swipeVc.getSlides()) === null || _a === void 0 ? void 0 : _a.map((_, idx) => {
+            return this.getPageVc(idx);
+        })) !== null && _b !== void 0 ? _b : []);
+    }
+    async handleClickDeletePage() {
+        const confirm = await this.confirm({
+            title: 'Are you sure?',
+            isDestructive: true,
+        });
+        if (confirm) {
+            await this.removePresentPage();
+        }
+    }
+    async handleClickAddPage() {
+        const addPageForm = this.Controller('form', (0, buildForm_1.default)({
+            id: 'addPageForm',
+            schema: {
+                id: 'addPage',
+                fields: {
+                    title: {
+                        label: 'Page name',
+                        type: 'text',
+                        isRequired: true,
+                    },
+                },
+            },
+            sections: [
+                {
+                    fields: [{ name: 'title', placeholder: this.buildNextPageTitle() }],
+                },
+            ],
+            shouldShowCancelButton: false,
+            submitButtonLabel: 'Add page',
+            onSubmit: async ({ values }) => {
+                if (values.title) {
+                    void dialog.hide();
+                    await this.addPage({
+                        title: values.title,
+                    });
+                }
+            },
+        }));
+        const dialog = this.renderInDialog({
+            header: { title: 'Add page' },
+            body: { sections: [{ form: addPageForm.render() }] },
+        });
+    }
+    handleClickAddSection(clickedSectionIdx) {
+        this.getPresentPageVc().getSection(clickedSectionIdx);
+        const vc = this.EditSectionVc({
+            onDone: async (section) => {
+                void dialog.hide();
+                const pageVc = this.getPresentPageVc();
+                pageVc.addSection(Object.assign(Object.assign({}, section), { atIndex: clickedSectionIdx + 1 }));
+            },
+        });
+        const dialog = this.renderInDialog(vc.render());
+    }
+    setShouldAllowEditing(shouldAllow) {
+        this.shouldAllowEditing = shouldAllow;
+    }
+    getShouldAllowEditing() {
+        var _a;
+        return (_a = this.shouldAllowEditing) !== null && _a !== void 0 ? _a : true;
+    }
+    handleClickEditSection(clickedSectionIdx) {
+        var _a;
+        const pageVc = this.getPresentPageVc();
+        const section = Object.assign({}, pageVc.getSection(clickedSectionIdx));
+        const fields = normalizeFieldNames_utility_1.default
+            .toNames((_a = section.fields) !== null && _a !== void 0 ? _a : [])
+            .map((f) => pageVc.getField(f).compiledOptions);
+        //@ts-ignore
+        section.fields = fields;
+        const vc = this.EditSectionVc({
+            editingSection: section,
+            onDone: async (section) => {
+                void dialog.hide();
+                const pageVc = this.getPresentPageVc();
+                pageVc.setSection(clickedSectionIdx, section);
+            },
+        });
+        const dialog = this.renderInDialog(vc.render());
+    }
+    handleClickPageTitles() {
+        const vc = this.Controller('managePageTitles', {
+            onDone: () => {
+                void dialog.hide();
+            },
+            formBuilderVc: this,
+        });
+        const dialog = this.renderInDialog(Object.assign({}, vc.render()));
+    }
+    EditSectionVc(options) {
+        const { onDone, editingSection } = options;
+        const editSectionVc = this.Controller('editFormBuilderSection', {
+            onDone,
+            pageSchema: this.getPresentPageVc().getSchema(),
+            editSection: editingSection,
+            defaultTitle: `Section ${this.getPresentPageVc().getTotalSections() + 1}`,
+        });
+        return editSectionVc;
+    }
+    handleClickEditField(fieldName) {
+        const pageVc = this.getPresentPageVc();
+        //@ts-ignore
+        const { compiledOptions } = pageVc.getField(fieldName);
+        const vc = this.Controller('editFormBuilderField', Object.assign(Object.assign({}, compiledOptions), { options: Object.assign({}, compiledOptions.options), onDone: (options) => {
+                const { name } = options, fieldDefinition = __rest(options, ["name"]);
+                void dialog.hide();
+                //@ts-ignore
+                pageVc.setField(fieldName, {
+                    newName: name,
+                    fieldDefinition,
+                });
+            } }));
+        const dialog = this.renderInDialog(Object.assign({}, vc.render()));
+    }
+    async toObject() {
+        var _a, _b, _c, _d, _e, _f;
+        const object = render_utility_1.default.render(this, {
+            shouldStripControllers: true,
+            shouldStripFunctions: true,
+            shouldStripPrivateFields: true,
+        });
+        return {
+            title: (_b = (_a = object.header) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : 'MISSING',
+            subtitle: (_c = object.header) === null || _c === void 0 ? void 0 : _c.subtitle,
+            pages: (_f = (_e = (_d = object.body) === null || _d === void 0 ? void 0 : _d.sections) === null || _e === void 0 ? void 0 : _e.map((s) => {
+                var _a, _b, _c;
+                return {
+                    title: s.title,
+                    schema: (_a = s.form) === null || _a === void 0 ? void 0 : _a.schema,
+                    sections: (_c = (_b = s.form) === null || _b === void 0 ? void 0 : _b.sections) !== null && _c !== void 0 ? _c : [],
+                };
+            })) !== null && _f !== void 0 ? _f : [],
+        };
+    }
+    async importObject(imported) {
+        this.swipeVc.setHeaderTitle(imported.title);
+        imported.subtitle && this.swipeVc.setHeaderSubtitle(imported.subtitle);
+        this.swipeVc.setSections([]);
+        for (const page of imported.pages) {
+            await this.addPage(page);
+        }
+    }
+    getValues() {
+        return this.getPageVcs().map((vc) => vc.getValues());
+    }
+    async setValues(values) {
+        if (!Array.isArray(values)) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['values'],
+                friendlyMessage: 'Values must be an array!',
+            });
+        }
+        await Promise.all(values.map((values, idx) => this.getPageVc(idx).setValues(values)));
+    }
+    render() {
+        return Object.assign(Object.assign({}, this.swipeVc.render()), { controller: this, shouldAllowEditing: this.shouldAllowEditing });
+    }
+}
+exports.default = FormBuilderCardViewController;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/formBuilder/FormBuilderPage.vc.d.ts

@@ -0,0 +1,54 @@
+import { Schema } from '@sprucelabs/schema';
+import { FormViewController } from '../../types/heartwood.types';
+import { SimpleSection } from './EditFormBuilderSectionCard.vc';
+import FormBuilderCardViewController from './FormBuilderCard.vc';
+export type FieldBuilder = FormBuilderCardViewController['buildField'];
+export type AddSectionOptions = Partial<SimpleSection> & {
+    atIndex?: number;
+};
+export interface FormBuilderPageViewControllerEnhancements {
+    getId(): string;
+    addSection(options?: AddSectionOptions): void;
+    setSection(sectionIdx: number, section: SimpleSection): void;
+    addField(sectionIdx: number, options?: {
+        name?: string;
+        type?: string;
+        label?: string;
+    }): void;
+    getIndex(): number;
+    getTitle(): string;
+    setTitle(string: string): void;
+    getSection(sectionIdx: number): SimpleSection;
+}
+export type FormBuilderPageViewController = Omit<FormViewController<Schema>, keyof FormBuilderPageViewControllerEnhancements> & FormBuilderPageViewControllerEnhancements;
+export declare class FormBuilderPageViewControllerImpl implements FormBuilderPageViewControllerEnhancements {
+    private formVc;
+    private fieldBuilder;
+    index: number;
+    private title;
+    private setTitleHandler;
+    private schema;
+    constructor(options: {
+        formVc: FormViewController<Schema>;
+        index: number;
+        title: string;
+        fieldBuilder: FieldBuilder;
+        setTitleHandler: (title: string) => void;
+        schema: Schema;
+    });
+    getTitle(): string;
+    getId(): string;
+    setTitle(title: string): void;
+    addField(sectionIdx: number, options?: {
+        name?: string;
+        type?: string;
+        label?: string;
+    }): void;
+    getIndex(): number;
+    private getTotalFields;
+    private buildNextFieldName;
+    setSection(sectionIdx: number, section: SimpleSection): void;
+    addSection(options?: AddSectionOptions): void;
+    getSection(sectionIdx: number): SimpleSection;
+    private addFieldsToSection;
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/formBuilder/FormBuilderPage.vc.js

@@ -0,0 +1,131 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormBuilderPageViewControllerImpl = void 0;
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const normalizeFieldNames_utility_1 = __importDefault(require("../../utilities/normalizeFieldNames.utility"));
+class FormBuilderPageViewControllerImpl {
+    constructor(options) {
+        const { formVc, fieldBuilder, index, setTitleHandler, title, schema } = options;
+        this.formVc = formVc;
+        this.index = index;
+        this.title = title;
+        this.schema = schema;
+        this.setTitleHandler = setTitleHandler;
+        this.fieldBuilder = fieldBuilder;
+        spruce_skill_utils_1.functionDelegationUtil.delegateFunctionCalls(this, formVc);
+    }
+    getTitle() {
+        return this.title;
+    }
+    getId() {
+        return spruce_skill_utils_1.namesUtil.toKebab(this.title);
+    }
+    setTitle(title) {
+        this.title = title;
+        this.setTitleHandler(title);
+    }
+    addField(sectionIdx, options) {
+        var _a;
+        const totalFields = this.getTotalFields();
+        const fieldName = (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : this.buildNextFieldName(totalFields);
+        const fieldDefinition = Object.assign({}, this.fieldBuilder(totalFields));
+        for (const key of Object.keys(options !== null && options !== void 0 ? options : {})) {
+            //@ts-ignore
+            if (options[key]) {
+                //@ts-ignore
+                fieldDefinition[key] = options[key];
+            }
+        }
+        this.formVc.addFields({
+            sectionIdx,
+            //@ts-ignore
+            fields: {
+                [fieldName]: fieldDefinition,
+            },
+        });
+    }
+    getIndex() {
+        return this.index;
+    }
+    getTotalFields() {
+        var _a;
+        return Object.keys((_a = this.formVc.getSchema().fields) !== null && _a !== void 0 ? _a : {}).length;
+    }
+    buildNextFieldName(totalFields) {
+        return `field${totalFields + 1}`;
+    }
+    setSection(sectionIdx, section) {
+        const { title, fields, text } = section, rest = __rest(section
+        //@ts-ignore
+        , ["title", "fields", "text"]);
+        //@ts-ignore
+        delete rest.type;
+        let updatedSection = Object.assign({ title }, rest);
+        if (text) {
+            updatedSection.text = { content: text };
+        }
+        this.formVc.setSection(sectionIdx, updatedSection);
+        this.addFieldsToSection(sectionIdx, fields !== null && fields !== void 0 ? fields : []);
+    }
+    addSection(options) {
+        let _a = options !== null && options !== void 0 ? options : {}, { title = `Section ${this.formVc.getTotalSections() + 1}`, fields = [{}], text, type } = _a, rest = __rest(_a, ["title", "fields", "text", "type"]);
+        const values = Object.assign({ title }, rest);
+        if (type === 'text') {
+            fields = [];
+            values.text = { content: text };
+        }
+        this.formVc.addSection(values);
+        this.addFieldsToSection(this.formVc.getTotalSections() - 1, fields);
+    }
+    getSection(sectionIdx) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const section = this.formVc.getSection(sectionIdx);
+        const simpleSection = {
+            title: (_a = section.title) !== null && _a !== void 0 ? _a : 'MISSING TITLE',
+            type: ((_b = section.text) === null || _b === void 0 ? void 0 : _b.content) ? 'text' : 'form',
+            shouldRenderAsGrid: (_c = section.shouldRenderAsGrid) !== null && _c !== void 0 ? _c : false,
+        };
+        const fields = normalizeFieldNames_utility_1.default.toObjects((_d = section.fields) !== null && _d !== void 0 ? _d : [], this.schema);
+        if (simpleSection.type === 'text') {
+            simpleSection.text = (_f = (_e = section.text) === null || _e === void 0 ? void 0 : _e.content) !== null && _f !== void 0 ? _f : '';
+        }
+        for (const field of fields) {
+            if (!simpleSection.fields) {
+                simpleSection.fields = [];
+            }
+            //@ts-ignore
+            simpleSection.fields.push({
+                //@ts-ignore
+                name: field.name,
+                label: (_g = field.label) !== null && _g !== void 0 ? _g : field.name,
+                //@ts-ignore
+                type: field.type,
+            });
+        }
+        return simpleSection;
+    }
+    addFieldsToSection(sectionIdx, fields) {
+        var _a;
+        for (const field of fields) {
+            let fieldName = field.label ? spruce_skill_utils_1.namesUtil.toCamel(field.label) : field.name;
+            //@ts-ignore
+            let type = (_a = field.type) !== null && _a !== void 0 ? _a : 'text';
+            this.addField(sectionIdx, Object.assign(Object.assign({}, field), { type, name: fieldName }));
+        }
+    }
+}
+exports.FormBuilderPageViewControllerImpl = FormBuilderPageViewControllerImpl;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/formBuilder/ManagePageTitlesCard.vc.d.ts

@@ -0,0 +1,15 @@
+import { ViewControllerOptions } from '../../types/heartwood.types';
+import CardViewController from '../card/Card.vc';
+import ListViewController from '../list/List.vc';
+import FormBuilderCardViewController from './FormBuilderCard.vc';
+export interface ManagePageTitlesCardViewControllerOptions {
+    onDone(): void;
+    formBuilderVc: FormBuilderCardViewController;
+}
+export default class ManagePageTitlesCardViewController extends CardViewController {
+    private listVc;
+    private formBuilderVc;
+    constructor(options: ManagePageTitlesCardViewControllerOptions & ViewControllerOptions);
+    private renderRows;
+    getListVc(): ListViewController;
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/formBuilder/ManagePageTitlesCard.vc.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const Card_vc_1 = __importDefault(require("../card/Card.vc"));
+class ManagePageTitlesCardViewController extends Card_vc_1.default {
+    constructor(options) {
+        super(options);
+        (0, schema_1.assertOptions)(options, ['onDone', 'formBuilderVc']);
+        this.formBuilderVc = options.formBuilderVc;
+        this.listVc = this.Controller('list', {
+            columnWidths: ['fill'],
+            rows: this.renderRows(),
+        });
+        this.model = {
+            header: {
+                title: 'Manage pages',
+            },
+            body: {
+                sections: [
+                    {
+                        list: this.listVc.render(),
+                    },
+                ],
+            },
+            footer: {
+                buttons: [
+                    {
+                        type: 'secondary',
+                        label: 'Add row',
+                        onClick: () => {
+                            void this.formBuilderVc.addPage();
+                            this.listVc.setRows(this.renderRows());
+                            this.triggerRender();
+                        },
+                    },
+                    {
+                        type: 'primary',
+                        label: 'Done',
+                        onClick: () => {
+                            options.onDone();
+                        },
+                    },
+                ],
+            },
+        };
+    }
+    renderRows() {
+        const pages = this.formBuilderVc.getPageVcs();
+        const rows = [];
+        let rowIdx = 0;
+        for (const page of pages) {
+            rows.push({
+                id: `page-${rowIdx++}`,
+                cells: [
+                    {
+                        textInput: {
+                            name: 'title',
+                            value: page.getTitle(),
+                            onChange: (value) => {
+                                if (value) {
+                                    page.setTitle(value);
+                                }
+                            },
+                        },
+                    },
+                    {
+                        button: {
+                            lineIcon: 'delete',
+                            type: 'destructive',
+                            onClick: async () => {
+                                const didConfirm = await this.confirm({
+                                    isDestructive: true,
+                                    title: 'Are you sure?',
+                                });
+                                if (didConfirm) {
+                                    await this.formBuilderVc.removePage(page.getIndex());
+                                    this.listVc.setRows(this.renderRows());
+                                }
+                            },
+                        },
+                    },
+                ],
+            });
+        }
+        return rows;
+    }
+    getListVc() {
+        return this.listVc;
+    }
+}
+exports.default = ManagePageTitlesCardViewController;

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

@@ -0,0 +1,46 @@
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas';
+import { List, ListColumnWidth, ListRow, ViewControllerOptions } from '../../types/heartwood.types';
+import AbstractViewController from '../Abstract.vc';
+import ListRowViewController from './ListRow.vc';
+export default class ListViewController extends AbstractViewController<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.List> {
+    private model;
+    private _rowVcs;
+    constructor(options: Partial<List> & ViewControllerOptions);
+    getRows(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ListRow[];
+    addRows(rows: ListRow[]): void;
+    setColumnWidths(widths: ListColumnWidth[]): void;
+    addRow(row: ListRow & {
+        atIndex?: number;
+    }): void;
+    getRowVc(row: number | string): ListRowViewController;
+    private assertValidRowIdx;
+    getTotalRows(): number;
+    private getRowValues;
+    private setValue;
+    getRowVcs(): ListRowViewController[];
+    getValues(): import("../../types/heartwood.types").RowValues[];
+    setRows(rows: ListRow[]): void;
+    deleteRow(rowIdx: number | string): void;
+    private getRowVcById;
+    private getIdxForId;
+    /**
+     * @deprecated Use upsertRow() instead.
+     */
+    upsertRowById(id: string, row: Omit<ListRow, 'id'>): void;
+    upsertRow(id: string, row: Omit<ListRow, 'id'>): void;
+    doesRowExist(id: string): boolean;
+    /**
+     * @deprecated doesIdExist() -> doesRowExist
+     */
+    doesIdExist(id: string): boolean;
+    private doesRowIdExistInModel;
+    private deleteRowById;
+    getSelectedRows(): string[];
+    selectRow(id: string | number): void;
+    deselectRow(id: string | number): void;
+    isRowSelected(row: string | number): boolean;
+    setSelectedRows(rows: (string | number)[]): void;
+    deleteAllRows(): void;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.List;
+}
+export type ListViewControllerOptions = Partial<List>;