diff --git a/.eslintrc.json b/.eslintrc.json index 2d525873a..f93c56b43 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -2,7 +2,8 @@ "env": { "browser": true, "es6": true, - "jest": true + "jest": true, + "node": true }, "parserOptions": { "ecmaVersion": 2019, diff --git a/package.json b/package.json index 57a3080fb..90403aba6 100644 --- a/package.json +++ b/package.json @@ -18,6 +18,7 @@ "dev": "lerna run --parallel --stream dev:builder", "test": "lerna run test", "lint": "eslint packages", + "lint:fix": "eslint --fix packages", "format": "prettier --write \"{,!(node_modules)/**/}*.{js,jsx}\"" } } diff --git a/packages/bootstrap-components/dist/generators.js b/packages/bootstrap-components/dist/generators.js index 1021b0975..d4187e4fc 100644 --- a/packages/bootstrap-components/dist/generators.js +++ b/packages/bootstrap-components/dist/generators.js @@ -1,450 +1,444 @@ const buttons = () => [ - { - name: "common/Primary Button", - description: "Bootstrap primary button ", - inherits: "@budibase/standard-components/button", - props: { - className: "btn btn-primary" - } + { + name: "common/Primary Button", + description: "Bootstrap primary button ", + inherits: "@budibase/standard-components/button", + props: { + className: "btn btn-primary", }, - { - name: "common/Default Button", - description: "Bootstrap default button", - inherits: "@budibase/standard-components/button", - props: { - className: "btn btn-secondary" - } - } -]; + }, + { + name: "common/Default Button", + description: "Bootstrap default button", + inherits: "@budibase/standard-components/button", + props: { + className: "btn btn-secondary", + }, + }, +] -const forms = ({records, indexes, helpers}) => - [ - ...records.map(root), - ...buttons() - ]; +const forms = ({ records, indexes, helpers }) => [ + ...records.map(root), + ...buttons(), +] -const formName = record => `${record.name}/${record.name} Form`; +const formName = record => `${record.name}/${record.name} Form` const root = record => ({ - name: formName(record), - description: `Control for creating/updating '${record.nodeKey()}' `, - inherits: "@budibase/standard-components/div", - props: { - className:"p-1", - children: [ - { - component: { - _component: "@budibase/standard-components/h3", - text: `Edit ${record.name}`, - } - }, - form(record), - saveCancelButtons(record) - ] - } -}); + name: formName(record), + description: `Control for creating/updating '${record.nodeKey()}' `, + inherits: "@budibase/standard-components/div", + props: { + className: "p-1", + children: [ + { + component: { + _component: "@budibase/standard-components/h3", + text: `Edit ${record.name}`, + }, + }, + form(record), + saveCancelButtons(record), + ], + }, +}) const form = record => ({ - component: { - _component: "@budibase/standard-components/form", - formControls: - record.fields.map(f => formControl(record, f)) - } -}); + component: { + _component: "@budibase/standard-components/form", + formControls: record.fields.map(f => formControl(record, f)), + }, +}) const formControl = (record, field) => { - if(field.type === "string" && field.typeOptions.values && field.typeOptions.values.length > 0) { - return ({ - control: { - _component: "@budibase/standard-components/select", - options: field.typeOptions.values.map(v => ({id:v, value:v})), - value: { - "##bbstate":`${record.name}.${field.name}`, - "##bbsource":"store" - }, - className: "form-control" - }, - label: field.label - }); - } else { - return ({ - control: { - _component: "@budibase/standard-components/input", - value: { - "##bbstate":`${record.name}.${field.name}`, - "##bbsource":"store" - }, - className: "form-control", - type: field.type === "string" ? "text" - : field.type === "datetime" ? "date" - : field.type === "number" ? "number" - : "text" - }, - label: field.label - }); - } -}; - -const saveCancelButtons = (record) => ({ - component: { - _component: "@budibase/standard-components/stackpanel", - direction: "horizontal", - children: [ - paddedPanelForButton({ - _component: "common/Primary Button", - contentText: `Save ${record.name}`, - onClick: [ - { - "##eventHandlerType": "Save Record", - parameters: { - statePath: `${record.name}`, - } - }, - { - "##eventHandlerType": "Set State", - parameters: { - path: `isEditing${record.name}`, - value: "" - } - } - ] - }), - paddedPanelForButton({ - _component: "common/Default Button", - contentText: `Cancel`, - onClick: [ - { - "##eventHandlerType": "Set State", - parameters: { - path: `isEditing${record.name}`, - value: "" - } - } - ] - }) - ] + if ( + field.type === "string" && + field.typeOptions.values && + field.typeOptions.values.length > 0 + ) { + return { + control: { + _component: "@budibase/standard-components/select", + options: field.typeOptions.values.map(v => ({ id: v, value: v })), + value: { + "##bbstate": `${record.name}.${field.name}`, + "##bbsource": "store", + }, + className: "form-control", + }, + label: field.label, } -}); - -const paddedPanelForButton = (button) => ({ - control: { - _component: "@budibase/standard-components/div", - className: "btn-group", - children: [ - { - component: button - } - ] + } else { + return { + control: { + _component: "@budibase/standard-components/input", + value: { + "##bbstate": `${record.name}.${field.name}`, + "##bbsource": "store", + }, + className: "form-control", + type: + field.type === "string" + ? "text" + : field.type === "datetime" + ? "date" + : field.type === "number" + ? "number" + : "text", + }, + label: field.label, } -}); - -const getRecordPath = (record) => { - - const parts = []; - - return parts.reverse().join("/"); -}; - -const indexTables = ({indexes, helpers}) => - indexes.map(i => indexTable(i, helpers)); - -const excludedColumns = ["id", "isNew", "key", "type", "sortKey"]; - -const indexTableProps = (index, helpers) => ({ - data: { - "##bbstate":index.nodeKey(), - "##bbsource":"store" - }, - tableClass: "table table-hover", - theadClass: "thead-dark", - columns: helpers - .indexSchema(index) - .filter(c => !excludedColumns.includes(c.name)) - .map(column), - onRowClick: [ - { + } +} + +const saveCancelButtons = record => ({ + component: { + _component: "@budibase/standard-components/stackpanel", + direction: "horizontal", + children: [ + paddedPanelForButton({ + _component: "common/Primary Button", + contentText: `Save ${record.name}`, + onClick: [ + { + "##eventHandlerType": "Save Record", + parameters: { + statePath: `${record.name}`, + }, + }, + { + "##eventHandlerType": "Set State", + parameters: { + path: `isEditing${record.name}`, + value: "", + }, + }, + ], + }), + paddedPanelForButton({ + _component: "common/Default Button", + contentText: `Cancel`, + onClick: [ + { "##eventHandlerType": "Set State", parameters: { - path: `selectedrow_${index.name}`, - value: { - "##bbstate": "key", - "##bbsource": "event" - } + path: `isEditing${record.name}`, + value: "", }, - } - ] -}); + }, + ], + }), + ], + }, +}) + +const paddedPanelForButton = button => ({ + control: { + _component: "@budibase/standard-components/div", + className: "btn-group", + children: [ + { + component: button, + }, + ], + }, +}) + +const getRecordPath = record => { + const parts = [] + + return parts.reverse().join("/") +} + +const indexTables = ({ indexes, helpers }) => + indexes.map(i => indexTable(i, helpers)) + +const excludedColumns = ["id", "isNew", "key", "type", "sortKey"] + +const indexTableProps = (index, helpers) => ({ + data: { + "##bbstate": index.nodeKey(), + "##bbsource": "store", + }, + tableClass: "table table-hover", + theadClass: "thead-dark", + columns: helpers + .indexSchema(index) + .filter(c => !excludedColumns.includes(c.name)) + .map(column), + onRowClick: [ + { + "##eventHandlerType": "Set State", + parameters: { + path: `selectedrow_${index.name}`, + value: { + "##bbstate": "key", + "##bbsource": "event", + }, + }, + }, + ], +}) const getIndexTableName = (index, record) => { - record = record - || index.parent().type === "record" ? index.parent() : null; - - return (record - ? `${getRecordPath()}/${index.name} Table` - : `${index.name} Table`); -}; + record = record || index.parent().type === "record" ? index.parent() : null + + return record + ? `${getRecordPath()}/${index.name} Table` + : `${index.name} Table` +} const indexTable = (index, helpers) => ({ - name: getIndexTableName(index), - inherits: "@budibase/standard-components/table", - props: indexTableProps(index, helpers) -}); - -const column = (col) => ({ - title: col.name, - value: { - "##bbstate": col.name, - "##bbsource":"context" - } -}); + name: getIndexTableName(index), + inherits: "@budibase/standard-components/table", + props: indexTableProps(index, helpers), +}) + +const column = col => ({ + title: col.name, + value: { + "##bbstate": col.name, + "##bbsource": "context", + }, +}) -const recordHomePageComponents = ({indexes, records, helpers}) => - [ - ...recordHomepages({indexes, records}) - .map(component), +const recordHomePageComponents = ({ indexes, records, helpers }) => [ + ...recordHomepages({ indexes, records }).map(component), - ...recordHomepages({indexes, records}) - .map(homePageButtons), - - ...indexTables({indexes, records, helpers}), + ...recordHomepages({ indexes, records }).map(homePageButtons), - ...buttons() - ]; + ...indexTables({ indexes, records, helpers }), + ...buttons(), +] const findIndexForRecord = (indexes, record) => { - const forRecord = indexes.filter(i => i.allowedRecordNodeIds.includes(record.nodeId)); - if(forRecord.length === 0) return; - if(forRecord.length === 1) return forRecord[0]; - const noMap = forRecord.filter(i => !i.filter || !i.filter.trim()); - if(noMap.length === 0) forRecord[0]; - return noMap[0]; -}; - -const recordHomepages = ({indexes, records}) => - records.filter(r => r.parent().type === "root") - .map(r =>({ - record:r, - index:findIndexForRecord(indexes, r) - })) - .filter(r => r.index); - - -const homepageComponentName = (record) => - `${record.name}/${record.name} homepage`; - -const component = ({record, index}) => ({ - inherits: "@budibase/standard-components/div", - name: homepageComponentName(record), - props: { - className: "d-flex flex-column h-100", - children: [ + const forRecord = indexes.filter(i => + i.allowedRecordNodeIds.includes(record.nodeId) + ) + if (forRecord.length === 0) return + if (forRecord.length === 1) return forRecord[0] + const noMap = forRecord.filter(i => !i.filter || !i.filter.trim()) + if (noMap.length === 0) forRecord[0] + return noMap[0] +} + +const recordHomepages = ({ indexes, records }) => + records + .filter(r => r.parent().type === "root") + .map(r => ({ + record: r, + index: findIndexForRecord(indexes, r), + })) + .filter(r => r.index) + +const homepageComponentName = record => `${record.name}/${record.name} homepage` + +const component = ({ record, index }) => ({ + inherits: "@budibase/standard-components/div", + name: homepageComponentName(record), + props: { + className: "d-flex flex-column h-100", + children: [ + { + component: { + _component: `${record.name}/homepage buttons`, + }, + }, + { + component: { + _component: getIndexTableName(index), + }, + className: "flex-gow-1 overflow-auto", + }, + ], + onLoad: [ + { + "##eventHandlerType": "Set State", + parameters: { + path: `isEditing${record.name}`, + value: "", + }, + }, + { + "##eventHandlerType": "List Records", + parameters: { + statePath: index.nodeKey(), + indexKey: index.nodeKey(), + }, + }, + ], + }, +}) + +const homePageButtons = ({ index, record }) => ({ + inherits: "@budibase/standard-components/div", + name: `${record.name}/homepage buttons`, + props: { + className: "btn-toolbar mt-4 mb-2", + children: [ + { + component: { + _component: "@budibase/standard-components/div", + className: "btn-group mr-3", + children: [ { - component: { - _component: `${record.name}/homepage buttons`, - } + component: { + _component: "common/Default Button", + contentText: `Create ${record.name}`, + onClick: [ + { + "##eventHandlerType": "Get New Record", + parameters: { + statePath: record.name, + collectionKey: `/${record.collectionName}`, + childRecordType: record.name, + }, + }, + { + "##eventHandlerType": "Set State", + parameters: { + path: `isEditing${record.name}`, + value: "true", + }, + }, + ], + }, }, { - component: { - _component: getIndexTableName(index) - }, - className: "flex-gow-1 overflow-auto" - } - ], - onLoad: [ - { - "##eventHandlerType": "Set State", - parameters: { - path: `isEditing${record.name}`, - value: "" - } + component: { + _component: "common/Default Button", + contentText: `Refresh`, + onClick: [ + { + "##eventHandlerType": "List Records", + parameters: { + statePath: index.nodeKey(), + indexKey: index.nodeKey(), + }, + }, + ], + }, }, - { - "##eventHandlerType": "List Records", - parameters: { - statePath: index.nodeKey(), - indexKey: index.nodeKey() - } - } - ] - } - -}); - -const homePageButtons = ({index, record}) => ({ - inherits: "@budibase/standard-components/div", - name: `${record.name}/homepage buttons`, - props: { - className: "btn-toolbar mt-4 mb-2", - children: [ - { + ], + }, + }, + { + component: { + _component: "@budibase/standard-components/if", + condition: `$store.selectedrow_${index.name} && $store.selectedrow_${index.name}.length > 0`, + thenComponent: { + _component: "@budibase/standard-components/div", + className: "btn-group", + children: [ + { component: { - _component: "@budibase/standard-components/div", - className: "btn-group mr-3", - children: [ - { - component: { - _component: "common/Default Button", - contentText: `Create ${record.name}`, - onClick: [ - { - "##eventHandlerType": "Get New Record", - parameters: { - statePath: record.name, - collectionKey: `/${record.collectionName}`, - childRecordType: record.name - } - }, - { - "##eventHandlerType": "Set State", - parameters: { - path: `isEditing${record.name}`, - value: "true" - } - } - ] - } + _component: "common/Default Button", + contentText: `Edit ${record.name}`, + onClick: [ + { + "##eventHandlerType": "Load Record", + parameters: { + statePath: record.name, + recordKey: { + "##bbstate": `selectedrow_${index.name}`, + "##source": "store", }, - { - component: { - _component: "common/Default Button", - contentText: `Refresh`, - onClick: [ - { - "##eventHandlerType": "List Records", - parameters: { - statePath: index.nodeKey(), - indexKey: index.nodeKey() - } - } - ] - } - } - ] - } - }, - { + }, + }, + { + "##eventHandlerType": "Set State", + parameters: { + path: `isEditing${record.name}`, + value: "true", + }, + }, + ], + }, + }, + { component: { - _component: "@budibase/standard-components/if", - condition: `$store.selectedrow_${index.name} && $store.selectedrow_${index.name}.length > 0`, - thenComponent: { - _component: "@budibase/standard-components/div", - className: "btn-group", - children: [ - { - component: { - _component: "common/Default Button", - contentText: `Edit ${record.name}`, - onClick: [ - { - "##eventHandlerType": "Load Record", - parameters: { - statePath: record.name, - recordKey: { - "##bbstate" : `selectedrow_${index.name}`, - "##source": "store" - } - } - }, - { - "##eventHandlerType": "Set State", - parameters: { - path: `isEditing${record.name}`, - value: "true" - } - } - ] - } - }, - { - component: { - _component: "common/Default Button", - contentText: `Delete ${record.name}`, - onClick: [ - { - "##eventHandlerType": "Delete Record", - parameters: { - recordKey: { - "##bbstate" : `selectedrow_${index.name}`, - "##source": "store" - } - } - } - ] - } - } - ] - } - } - } - ] - } -}); - -const selectNavContent = ({indexes, records, helpers}) => - [ - ...recordHomepages({indexes, records}) - .map(component$1), - - ...recordHomePageComponents({indexes, records, helpers}), + _component: "common/Default Button", + contentText: `Delete ${record.name}`, + onClick: [ + { + "##eventHandlerType": "Delete Record", + parameters: { + recordKey: { + "##bbstate": `selectedrow_${index.name}`, + "##source": "store", + }, + }, + }, + ], + }, + }, + ], + }, + }, + }, + ], + }, +}) - ...forms({indexes, records, helpers}) +const selectNavContent = ({ indexes, records, helpers }) => [ + ...recordHomepages({ indexes, records }).map(component$1), - ]; + ...recordHomePageComponents({ indexes, records, helpers }), + ...forms({ indexes, records, helpers }), +] const navContentComponentName = record => - `${record.name}/${record.name} Nav Content`; - -const component$1 = ({record, index}) => ({ - inherits: "@budibase/standard-components/if", - description: `the component that gets displayed when the ${record.collectionName} nav is selected`, - name: navContentComponentName(record), - props: { - condition: `$store.isEditing${record.name}`, - thenComponent: { - _component: formName(record) - }, - elseComponent: { - _component: homepageComponentName(record) - } - } -}); - -const app = ({records, indexes, helpers}) => [ - { - name: "Application Root", - inherits: "@budibase/bootstrap-components/nav", - props: { - items: recordHomepages({indexes, records}) - .map(navItem), - orientation: "horizontal", - alignment: "start", - fill: false, - pills: true, - selectedItem: { - "##bbstate":"selectedNav", - "##bbstatefallback":`${records[0].name}`, - "##bbsource": "store" - }, - className: "p-3" - } + `${record.name}/${record.name} Nav Content` + +const component$1 = ({ record, index }) => ({ + inherits: "@budibase/standard-components/if", + description: `the component that gets displayed when the ${record.collectionName} nav is selected`, + name: navContentComponentName(record), + props: { + condition: `$store.isEditing${record.name}`, + thenComponent: { + _component: formName(record), }, - { - name: "Login", - inherits: "@budibase/standard-components/login", - props: {} + elseComponent: { + _component: homepageComponentName(record), }, - ...selectNavContent({records, indexes, helpers}) -]; - - -const navItem = ({record}) => ({ - title: record.collectionName, - component : { - _component: navContentComponentName(record) - } -}); + }, +}) -export { app, forms, indexTables, recordHomePageComponents as recordHomepages }; +const app = ({ records, indexes, helpers }) => [ + { + name: "Application Root", + inherits: "@budibase/bootstrap-components/nav", + props: { + items: recordHomepages({ indexes, records }).map(navItem), + orientation: "horizontal", + alignment: "start", + fill: false, + pills: true, + selectedItem: { + "##bbstate": "selectedNav", + "##bbstatefallback": `${records[0].name}`, + "##bbsource": "store", + }, + className: "p-3", + }, + }, + { + name: "Login", + inherits: "@budibase/standard-components/login", + props: {}, + }, + ...selectNavContent({ records, indexes, helpers }), +] + +const navItem = ({ record }) => ({ + title: record.collectionName, + component: { + _component: navContentComponentName(record), + }, +}) + +export { app, forms, indexTables, recordHomePageComponents as recordHomepages } //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"generators.js","sources":["../src/generators/buttonGenerators.js","../src/generators/formsGenerator.js","../src/generators/getRecordPath.js","../src/generators/indexTablesGenerator.js","../src/generators/recordHomePageGenerator.js","../src/generators/selectedNavContentGenerator.js","../src/generators/appGenerator.js"],"sourcesContent":["export const buttons = () => [\r\n    {\r\n        name: \"common/Primary Button\",\r\n        description: \"Bootstrap primary button \",\r\n        inherits: \"@budibase/standard-components/button\",\r\n        props: {\r\n            className: \"btn btn-primary\"\r\n        }\r\n    },\r\n    {\r\n        name: \"common/Default Button\",\r\n        description: \"Bootstrap default button\",\r\n        inherits: \"@budibase/standard-components/button\",\r\n        props: {\r\n            className: \"btn btn-secondary\"\r\n        }\r\n    }\r\n]","import {buttons} from \"./buttonGenerators\";\r\n\r\nexport const forms = ({records, indexes, helpers}) => \r\n    [\r\n        ...records.map(root),\r\n        ...buttons({records, indexes, helpers})\r\n    ];\r\n\r\nexport const formName = record =>  `${record.name}/${record.name} Form`;\r\n\r\nconst root = record => ({\r\n    name: formName(record),\r\n    description: `Control for creating/updating '${record.nodeKey()}' `,\r\n    inherits: \"@budibase/standard-components/div\",\r\n    props: {\r\n        className:\"p-1\",\r\n        children: [\r\n            {\r\n                component: {\r\n                    _component: \"@budibase/standard-components/h3\",\r\n                    text: `Edit ${record.name}`,\r\n                }\r\n            },\r\n            form(record),\r\n            saveCancelButtons(record)\r\n        ]\r\n    }\r\n}) \r\n\r\nconst form = record => ({\r\n    component: {\r\n        _component: \"@budibase/standard-components/form\",\r\n        formControls: \r\n            record.fields.map(f => formControl(record, f))\r\n    }\r\n})\r\n\r\nconst formControl = (record, field) => {\r\n    if(field.type === \"string\" && field.typeOptions.values && field.typeOptions.values.length > 0) {\r\n        return ({\r\n            control: {\r\n                _component: \"@budibase/standard-components/select\",\r\n                options: field.typeOptions.values.map(v => ({id:v, value:v})),\r\n                value: {\r\n                    \"##bbstate\":`${record.name}.${field.name}`,\r\n                    \"##bbsource\":\"store\"\r\n                },\r\n                className: \"form-control\"\r\n            },\r\n            label: field.label\r\n        });\r\n    } else {\r\n        return ({\r\n            control: {\r\n                _component: \"@budibase/standard-components/input\",\r\n                value: {\r\n                    \"##bbstate\":`${record.name}.${field.name}`,\r\n                    \"##bbsource\":\"store\"\r\n                },\r\n                className: \"form-control\",\r\n                type: field.type === \"string\" ? \"text\"\r\n                    : field.type === \"datetime\" ? \"date\"\r\n                    : field.type === \"number\" ? \"number\"\r\n                    : \"text\"\r\n            },\r\n            label: field.label\r\n        });\r\n    }\r\n}\r\n\r\nconst saveCancelButtons = (record) => ({\r\n    component: {\r\n        _component: \"@budibase/standard-components/stackpanel\",\r\n        direction: \"horizontal\",\r\n        children: [\r\n            paddedPanelForButton({\r\n                _component: \"common/Primary Button\",\r\n                contentText: `Save ${record.name}`,\r\n                onClick: [                \r\n                    {\r\n                        \"##eventHandlerType\": \"Save Record\",\r\n                        parameters: {\r\n                            statePath: `${record.name}`,\r\n                        }\r\n                    },\r\n                    {\r\n                        \"##eventHandlerType\": \"Set State\",\r\n                        parameters: {\r\n                            path: `isEditing${record.name}`,\r\n                            value: \"\"\r\n                        }\r\n                    }\r\n                ]\r\n            }),\r\n            paddedPanelForButton({\r\n                _component: \"common/Default Button\",\r\n                contentText: `Cancel`,\r\n                onClick: [\r\n                    {\r\n                        \"##eventHandlerType\": \"Set State\",\r\n                        parameters: {\r\n                            path: `isEditing${record.name}`,\r\n                            value: \"\"\r\n                        }\r\n                    }\r\n                ]\r\n            })\r\n        ]\r\n    }\r\n})\r\n\r\nconst paddedPanelForButton = (button) => ({\r\n    control: {\r\n        _component: \"@budibase/standard-components/div\",\r\n        className: \"btn-group\",\r\n        children: [\r\n            {\r\n                component: button\r\n            }\r\n        ]\r\n    }\r\n});\r\n\r\n","export const getRecordPath = (record) => {\r\n\r\n    const parts = [];\r\n\r\n    const add = (current) => {\r\n        parts.push(current.name);\r\n        if(current.parent().type === \"root\") {\r\n            return;\r\n        }\r\n\r\n        add(current.parent());\r\n    }\r\n\r\n    return parts.reverse().join(\"/\");\r\n}","import { getRecordPath } from \"./getRecordPath\";\r\n\r\nexport const indexTables = ({indexes, helpers}) => \r\n    indexes.map(i => indexTable(i, helpers));\r\n\r\nconst excludedColumns = [\"id\", \"isNew\", \"key\", \"type\", \"sortKey\"];\r\n\r\nexport const indexTableProps = (index, helpers) => ({\r\n    data: {\r\n        \"##bbstate\":index.nodeKey(),\r\n        \"##bbsource\":\"store\"\r\n    },\r\n    tableClass: \"table table-hover\",\r\n    theadClass: \"thead-dark\",\r\n    columns: helpers\r\n                .indexSchema(index)\r\n                .filter(c => !excludedColumns.includes(c.name))\r\n                .map(column),\r\n    onRowClick: [\r\n        {\r\n            \"##eventHandlerType\": \"Set State\",\r\n            parameters: {\r\n                path: `selectedrow_${index.name}`,\r\n                value: {\r\n                    \"##bbstate\": \"key\",\r\n                    \"##bbsource\": \"event\"\r\n                }\r\n            },\r\n        }\r\n    ]\r\n});\r\n\r\nexport const getIndexTableName = (index, record) => {\r\n    record = record \r\n             || index.parent().type === \"record\" ? index.parent() : null;\r\n    \r\n    return (record\r\n            ? `${getRecordPath(record)}/${index.name} Table`\r\n            : `${index.name} Table`);\r\n}\r\n\r\nconst indexTable = (index, helpers) => ({\r\n    name: getIndexTableName(index),\r\n    inherits: \"@budibase/standard-components/table\",\r\n    props: indexTableProps(index, helpers)\r\n});\r\n\r\nconst column = (col) => ({\r\n    title: col.name,\r\n    value: {\r\n        \"##bbstate\": col.name,\r\n        \"##bbsource\":\"context\"\r\n    }\r\n})","import {\r\n    getIndexTableName, indexTables\r\n} from \"./indexTablesGenerator\";\r\n\r\nimport {\r\n    buttons\r\n} from \"./buttonGenerators\";\r\n\r\nexport const recordHomePageComponents = ({indexes, records, helpers}) => \r\n    [   \r\n        ...recordHomepages({indexes, records})\r\n          .map(component),\r\n\r\n        ...recordHomepages({indexes, records})\r\n            .map(homePageButtons),\r\n        \r\n        ...indexTables({indexes, records, helpers}),\r\n\r\n        ...buttons({indexes, buttons, helpers})\r\n    ]\r\n\r\n\r\nconst findIndexForRecord = (indexes, record) => {\r\n    const forRecord = indexes.filter(i => i.allowedRecordNodeIds.includes(record.nodeId));\r\n    if(forRecord.length === 0) return;\r\n    if(forRecord.length === 1) return forRecord[0];\r\n    const noMap = forRecord.filter(i => !i.filter || !i.filter.trim());\r\n    if(noMap.length === 0) forRecord[0];\r\n    return noMap[0];\r\n}\r\n\r\nexport const recordHomepages = ({indexes, records}) => \r\n    records.filter(r => r.parent().type === \"root\")\r\n        .map(r =>({\r\n            record:r, \r\n            index:findIndexForRecord(indexes, r)\r\n        }))\r\n        .filter(r => r.index);\r\n\r\n\r\nexport const  homepageComponentName = (record) => \r\n    `${record.name}/${record.name} homepage`;\r\n\r\nconst component = ({record, index}) => ({\r\n    inherits: \"@budibase/standard-components/div\",\r\n    name: homepageComponentName(record),\r\n    props: {\r\n        className: \"d-flex flex-column h-100\",\r\n        children: [\r\n            {\r\n                component: {\r\n                    _component: `${record.name}/homepage buttons`,\r\n                }\r\n            },\r\n            {\r\n                component: {\r\n                    _component: getIndexTableName(index)\r\n                },\r\n                className: \"flex-gow-1 overflow-auto\"\r\n            }\r\n        ],\r\n        onLoad: [\r\n            {\r\n                \"##eventHandlerType\": \"Set State\",\r\n                parameters: {\r\n                    path: `isEditing${record.name}`,\r\n                    value: \"\"\r\n                }\r\n            },\r\n            {\r\n                \"##eventHandlerType\": \"List Records\",\r\n                parameters: {\r\n                    statePath: index.nodeKey(),\r\n                    indexKey: index.nodeKey()\r\n                }\r\n            }\r\n        ]\r\n    }\r\n\r\n});\r\n\r\nconst homePageButtons = ({index, record}) => ({\r\n    inherits: \"@budibase/standard-components/div\",\r\n    name: `${record.name}/homepage buttons`,\r\n    props: {\r\n        className: \"btn-toolbar mt-4 mb-2\",\r\n        children: [\r\n            {\r\n                component: {\r\n                    _component: \"@budibase/standard-components/div\",\r\n                    className: \"btn-group mr-3\",\r\n                    children: [\r\n                        {\r\n                            component: {\r\n                                _component: \"common/Default Button\",\r\n                                contentText: `Create ${record.name}`,\r\n                                onClick: [\r\n                                    {\r\n                                        \"##eventHandlerType\": \"Get New Record\",\r\n                                        parameters: {\r\n                                            statePath: record.name,\r\n                                            collectionKey: `/${record.collectionName}`,\r\n                                            childRecordType: record.name\r\n                                        }\r\n                                    }, \r\n                                    {\r\n                                        \"##eventHandlerType\": \"Set State\",\r\n                                        parameters: {\r\n                                            path: `isEditing${record.name}`,\r\n                                            value: \"true\"\r\n                                        }\r\n                                    }\r\n                                ]\r\n                            }\r\n                        },\r\n                        {\r\n                            component: {\r\n                                _component: \"common/Default Button\",\r\n                                contentText: `Refresh`,\r\n                                onClick: [\r\n                                    {\r\n                                        \"##eventHandlerType\": \"List Records\",\r\n                                        parameters: {\r\n                                            statePath: index.nodeKey(),\r\n                                            indexKey: index.nodeKey()\r\n                                        }\r\n                                    }\r\n                                ]\r\n                            }\r\n                        }\r\n                    ]\r\n                }\r\n            },\r\n            {\r\n                component: {\r\n                    _component: \"@budibase/standard-components/if\",\r\n                    condition: `$store.selectedrow_${index.name} && $store.selectedrow_${index.name}.length > 0`,\r\n                    thenComponent: {\r\n                        _component: \"@budibase/standard-components/div\",\r\n                        className: \"btn-group\",\r\n                        children: [\r\n                            {\r\n                                component: {\r\n                                    _component: \"common/Default Button\",\r\n                                    contentText: `Edit ${record.name}`,\r\n                                    onClick: [\r\n                                        {\r\n                                            \"##eventHandlerType\": \"Load Record\",\r\n                                            parameters: {\r\n                                                statePath: record.name,\r\n                                                recordKey: {\r\n                                                    \"##bbstate\" : `selectedrow_${index.name}`,\r\n                                                    \"##source\": \"store\"\r\n                                                }\r\n                                            }\r\n                                        }, \r\n                                        {\r\n                                            \"##eventHandlerType\": \"Set State\",\r\n                                            parameters: {\r\n                                                path: `isEditing${record.name}`,\r\n                                                value: \"true\"\r\n                                            }\r\n                                        }\r\n                                    ]\r\n                                }\r\n                            },\r\n                            {\r\n                                component: {\r\n                                    _component: \"common/Default Button\",\r\n                                    contentText: `Delete ${record.name}`,\r\n                                    onClick: [\r\n                                        {\r\n                                            \"##eventHandlerType\": \"Delete Record\",\r\n                                            parameters: {\r\n                                                recordKey: {\r\n                                                    \"##bbstate\" : `selectedrow_${index.name}`,\r\n                                                    \"##source\": \"store\"\r\n                                                }\r\n                                            }\r\n                                        }\r\n                                    ]\r\n                                }\r\n                            }\r\n                        ]\r\n                    }\r\n                }\r\n            }\r\n        ]\r\n    }\r\n})","import { \r\n    recordHomepages, \r\n    homepageComponentName,\r\n    recordHomePageComponents\r\n} from \"./recordHomePageGenerator\";\r\nimport { formName, forms } from \"./formsGenerator\";\r\n\r\nexport const selectNavContent = ({indexes, records, helpers}) => \r\n    [\r\n        ...recordHomepages({indexes, records})\r\n            .map(component),\r\n\r\n        ...recordHomePageComponents({indexes, records, helpers}),\r\n\r\n        ...forms({indexes, records, helpers})\r\n\r\n    ]\r\n\r\n\r\nexport const navContentComponentName = record =>\r\n    `${record.name}/${record.name} Nav Content`;\r\n\r\nconst component = ({record, index}) => ({\r\n    inherits: \"@budibase/standard-components/if\",\r\n    description: `the component that gets displayed when the ${record.collectionName} nav is selected`,\r\n    name: navContentComponentName(record),\r\n    props: {\r\n        condition: `$store.isEditing${record.name}`,\r\n        thenComponent: {\r\n            _component: formName(record)\r\n        },\r\n        elseComponent: {\r\n            _component: homepageComponentName(record)\r\n        }\r\n    }\r\n});","import { navContentComponentName, selectNavContent } from \"./selectedNavContentGenerator\";\r\nimport { recordHomepages } from \"./recordHomePageGenerator\";\r\nexport const app = ({records, indexes, helpers}) => [\r\n    {\r\n        name: \"Application Root\",\r\n        inherits: \"@budibase/bootstrap-components/nav\",\r\n        props: {\r\n            items: recordHomepages({indexes, records})\r\n                    .map(navItem),\r\n            orientation: \"horizontal\",\r\n            alignment: \"start\",\r\n            fill: false,\r\n            pills: true,\r\n            selectedItem: {\r\n                \"##bbstate\":\"selectedNav\",\r\n                \"##bbstatefallback\":`${records[0].name}`,\r\n                \"##bbsource\": \"store\"\r\n            },\r\n            className: \"p-3\"\r\n        }\r\n    },\r\n    {\r\n        name: \"Login\",\r\n        inherits: \"@budibase/standard-components/login\",\r\n        props: {}\r\n    },\r\n    ...selectNavContent({records, indexes, helpers})\r\n]\r\n\r\n\r\nexport const navItem = ({record}) => ({\r\n    title: record.collectionName,\r\n    component : {\r\n        _component: navContentComponentName(record)\r\n    }\r\n})\r\n\r\n"],"names":["component"],"mappings":"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"} diff --git a/packages/bootstrap-components/public/bundle.js b/packages/bootstrap-components/public/bundle.js index 949818b21..c8f91c592 100644 --- a/packages/bootstrap-components/public/bundle.js +++ b/packages/bootstrap-components/public/bundle.js @@ -1,6253 +1,13096 @@ - -(function(l, i, v, e) { v = l.createElement(i); v.async = 1; v.src = '//' + (location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; e = l.getElementsByTagName(i)[0]; e.parentNode.insertBefore(v, e)})(document, 'script'); -var app = (function () { - 'use strict'; - - function noop() { } - function assign(tar, src) { - // @ts-ignore - for (const k in src) - tar[k] = src[k]; - return tar; +;(function(l, i, v, e) { + v = l.createElement(i) + v.async = 1 + v.src = + "//" + + (location.host || "localhost").split(":")[0] + + ":35729/livereload.js?snipver=1" + e = l.getElementsByTagName(i)[0] + e.parentNode.insertBefore(v, e) +})(document, "script") +var app = (function() { + "use strict" + + function noop() {} + function assign(tar, src) { + // @ts-ignore + for (const k in src) tar[k] = src[k] + return tar + } + function is_promise(value) { + return ( + value && typeof value === "object" && typeof value.then === "function" + ) + } + function add_location(element, file, line, column, char) { + element.__svelte_meta = { + loc: { file, line, column, char }, } - function is_promise(value) { - return value && typeof value === 'object' && typeof value.then === 'function'; + } + function run(fn) { + return fn() + } + function blank_object() { + return Object.create(null) + } + function run_all(fns) { + fns.forEach(run) + } + function is_function(thing) { + return typeof thing === "function" + } + function safe_not_equal(a, b) { + return a != a + ? b == b + : a !== b || (a && typeof a === "object") || typeof a === "function" + } + function create_slot(definition, ctx, fn) { + if (definition) { + const slot_ctx = get_slot_context(definition, ctx, fn) + return definition[0](slot_ctx) } - function add_location(element, file, line, column, char) { - element.__svelte_meta = { - loc: { file, line, column, char } - }; + } + function get_slot_context(definition, ctx, fn) { + return definition[1] + ? assign({}, assign(ctx.$$scope.ctx, definition[1](fn ? fn(ctx) : {}))) + : ctx.$$scope.ctx + } + function get_slot_changes(definition, ctx, changed, fn) { + return definition[1] + ? assign( + {}, + assign( + ctx.$$scope.changed || {}, + definition[1](fn ? fn(changed) : {}) + ) + ) + : ctx.$$scope.changed || {} + } + function null_to_empty(value) { + return value == null ? "" : value + } + + function append(target, node) { + target.appendChild(node) + } + function insert(target, node, anchor) { + target.insertBefore(node, anchor || null) + } + function detach(node) { + node.parentNode.removeChild(node) + } + function destroy_each(iterations, detaching) { + for (let i = 0; i < iterations.length; i += 1) { + if (iterations[i]) iterations[i].d(detaching) } - function run(fn) { - return fn(); + } + function element(name) { + return document.createElement(name) + } + function svg_element(name) { + return document.createElementNS("http://www.w3.org/2000/svg", name) + } + function text(data) { + return document.createTextNode(data) + } + function space() { + return text(" ") + } + function empty() { + return text("") + } + function listen(node, event, handler, options) { + node.addEventListener(event, handler, options) + return () => node.removeEventListener(event, handler, options) + } + function attr(node, attribute, value) { + if (value == null) node.removeAttribute(attribute) + else node.setAttribute(attribute, value) + } + function children(element) { + return Array.from(element.childNodes) + } + function claim_element(nodes, name, attributes, svg) { + for (let i = 0; i < nodes.length; i += 1) { + const node = nodes[i] + if (node.nodeName === name) { + for (let j = 0; j < node.attributes.length; j += 1) { + const attribute = node.attributes[j] + if (!attributes[attribute.name]) node.removeAttribute(attribute.name) + } + return nodes.splice(i, 1)[0] // TODO strip unwanted attributes + } } - function blank_object() { - return Object.create(null); + return svg ? svg_element(name) : element(name) + } + function claim_text(nodes, data) { + for (let i = 0; i < nodes.length; i += 1) { + const node = nodes[i] + if (node.nodeType === 3) { + node.data = "" + data + return nodes.splice(i, 1)[0] + } } - function run_all(fns) { - fns.forEach(run); + return text(data) + } + function claim_space(nodes) { + return claim_text(nodes, " ") + } + function set_input_value(input, value) { + if (value != null || input.value) { + input.value = value } - function is_function(thing) { - return typeof thing === 'function'; + } + function set_style(node, key, value, important) { + node.style.setProperty(key, value, important ? "important" : "") + } + function toggle_class(element, name, toggle) { + element.classList[toggle ? "add" : "remove"](name) + } + function custom_event(type, detail) { + const e = document.createEvent("CustomEvent") + e.initCustomEvent(type, false, false, detail) + return e + } + + let current_component + function set_current_component(component) { + current_component = component + } + function get_current_component() { + if (!current_component) + throw new Error(`Function called outside component initialization`) + return current_component + } + // TODO figure out if we still want to support + // shorthand events, or if we want to implement + // a real bubbling mechanism + function bubble(component, event) { + const callbacks = component.$$.callbacks[event.type] + if (callbacks) { + callbacks.slice().forEach(fn => fn(event)) } - function safe_not_equal(a, b) { - return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function'); + } + + const dirty_components = [] + const binding_callbacks = [] + const render_callbacks = [] + const flush_callbacks = [] + const resolved_promise = Promise.resolve() + let update_scheduled = false + function schedule_update() { + if (!update_scheduled) { + update_scheduled = true + resolved_promise.then(flush) } - function create_slot(definition, ctx, fn) { - if (definition) { - const slot_ctx = get_slot_context(definition, ctx, fn); - return definition[0](slot_ctx); + } + function add_render_callback(fn) { + render_callbacks.push(fn) + } + function flush() { + const seen_callbacks = new Set() + do { + // first, call beforeUpdate functions + // and update components + while (dirty_components.length) { + const component = dirty_components.shift() + set_current_component(component) + update(component.$$) + } + while (binding_callbacks.length) binding_callbacks.pop()() + // then, once components are updated, call + // afterUpdate functions. This may cause + // subsequent updates... + for (let i = 0; i < render_callbacks.length; i += 1) { + const callback = render_callbacks[i] + if (!seen_callbacks.has(callback)) { + callback() + // ...so guard against infinite loops + seen_callbacks.add(callback) } + } + render_callbacks.length = 0 + } while (dirty_components.length) + while (flush_callbacks.length) { + flush_callbacks.pop()() } - function get_slot_context(definition, ctx, fn) { - return definition[1] - ? assign({}, assign(ctx.$$scope.ctx, definition[1](fn ? fn(ctx) : {}))) - : ctx.$$scope.ctx; - } - function get_slot_changes(definition, ctx, changed, fn) { - return definition[1] - ? assign({}, assign(ctx.$$scope.changed || {}, definition[1](fn ? fn(changed) : {}))) - : ctx.$$scope.changed || {}; + update_scheduled = false + } + function update($$) { + if ($$.fragment) { + $$.update($$.dirty) + run_all($$.before_update) + $$.fragment.p($$.dirty, $$.ctx) + $$.dirty = null + $$.after_update.forEach(add_render_callback) } - function null_to_empty(value) { - return value == null ? '' : value; + } + const outroing = new Set() + let outros + function group_outros() { + outros = { + r: 0, + c: [], + p: outros, // parent group } - - function append(target, node) { - target.appendChild(node); + } + function check_outros() { + if (!outros.r) { + run_all(outros.c) } - function insert(target, node, anchor) { - target.insertBefore(node, anchor || null); + outros = outros.p + } + function transition_in(block, local) { + if (block && block.i) { + outroing.delete(block) + block.i(local) } - function detach(node) { - node.parentNode.removeChild(node); + } + function transition_out(block, local, detach, callback) { + if (block && block.o) { + if (outroing.has(block)) return + outroing.add(block) + outros.c.push(() => { + outroing.delete(block) + if (callback) { + if (detach) block.d(1) + callback() + } + }) + block.o(local) } - function destroy_each(iterations, detaching) { - for (let i = 0; i < iterations.length; i += 1) { - if (iterations[i]) - iterations[i].d(detaching); + } + + function handle_promise(promise, info) { + const token = (info.token = {}) + function update(type, index, key, value) { + if (info.token !== token) return + info.resolved = key && { [key]: value } + const child_ctx = assign(assign({}, info.ctx), info.resolved) + const block = type && (info.current = type)(child_ctx) + if (info.block) { + if (info.blocks) { + info.blocks.forEach((block, i) => { + if (i !== index && block) { + group_outros() + transition_out(block, 1, 1, () => { + info.blocks[i] = null + }) + check_outros() + } + }) + } else { + info.block.d(1) } + block.c() + transition_in(block, 1) + block.m(info.mount(), info.anchor) + flush() + } + info.block = block + if (info.blocks) info.blocks[index] = block } - function element(name) { - return document.createElement(name); - } - function svg_element(name) { - return document.createElementNS('http://www.w3.org/2000/svg', name); - } - function text(data) { - return document.createTextNode(data); - } - function space() { - return text(' '); - } - function empty() { - return text(''); - } - function listen(node, event, handler, options) { - node.addEventListener(event, handler, options); - return () => node.removeEventListener(event, handler, options); + if (is_promise(promise)) { + const current_component = get_current_component() + promise.then( + value => { + set_current_component(current_component) + update(info.then, 1, info.value, value) + set_current_component(null) + }, + error => { + set_current_component(current_component) + update(info.catch, 2, info.error, error) + set_current_component(null) + } + ) + // if we previously had a then/catch block, destroy it + if (info.current !== info.pending) { + update(info.pending, 0) + return true + } + } else { + if (info.current !== info.then) { + update(info.then, 1, info.value, promise) + return true + } + info.resolved = { [info.value]: promise } } - function attr(node, attribute, value) { - if (value == null) - node.removeAttribute(attribute); - else - node.setAttribute(attribute, value); + } + + const globals = typeof window !== "undefined" ? window : global + function mount_component(component, target, anchor) { + const { fragment, on_mount, on_destroy, after_update } = component.$$ + fragment.m(target, anchor) + // onMount happens before the initial afterUpdate + add_render_callback(() => { + const new_on_destroy = on_mount.map(run).filter(is_function) + if (on_destroy) { + on_destroy.push(...new_on_destroy) + } else { + // Edge case - component was destroyed immediately, + // most likely as a result of a binding initialising + run_all(new_on_destroy) + } + component.$$.on_mount = [] + }) + after_update.forEach(add_render_callback) + } + function destroy_component(component, detaching) { + if (component.$$.fragment) { + run_all(component.$$.on_destroy) + component.$$.fragment.d(detaching) + // TODO null out other refs, including component.$$ (but need to + // preserve final state?) + component.$$.on_destroy = component.$$.fragment = null + component.$$.ctx = {} } - function children(element) { - return Array.from(element.childNodes); + } + function make_dirty(component, key) { + if (!component.$$.dirty) { + dirty_components.push(component) + schedule_update() + component.$$.dirty = blank_object() } - function claim_element(nodes, name, attributes, svg) { - for (let i = 0; i < nodes.length; i += 1) { - const node = nodes[i]; - if (node.nodeName === name) { - for (let j = 0; j < node.attributes.length; j += 1) { - const attribute = node.attributes[j]; - if (!attributes[attribute.name]) - node.removeAttribute(attribute.name); - } - return nodes.splice(i, 1)[0]; // TODO strip unwanted attributes - } - } - return svg ? svg_element(name) : element(name); + component.$$.dirty[key] = true + } + function init( + component, + options, + instance, + create_fragment, + not_equal, + prop_names + ) { + const parent_component = current_component + set_current_component(component) + const props = options.props || {} + const $$ = (component.$$ = { + fragment: null, + ctx: null, + // state + props: prop_names, + update: noop, + not_equal, + bound: blank_object(), + // lifecycle + on_mount: [], + on_destroy: [], + before_update: [], + after_update: [], + context: new Map(parent_component ? parent_component.$$.context : []), + // everything else + callbacks: blank_object(), + dirty: null, + }) + let ready = false + $$.ctx = instance + ? instance(component, props, (key, ret, value = ret) => { + if ($$.ctx && not_equal($$.ctx[key], ($$.ctx[key] = value))) { + if ($$.bound[key]) $$.bound[key](value) + if (ready) make_dirty(component, key) + } + return ret + }) + : props + $$.update() + ready = true + run_all($$.before_update) + $$.fragment = create_fragment($$.ctx) + if (options.target) { + if (options.hydrate) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + $$.fragment.l(children(options.target)) + } else { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + $$.fragment.c() + } + if (options.intro) transition_in(component.$$.fragment) + mount_component(component, options.target, options.anchor) + flush() } - function claim_text(nodes, data) { - for (let i = 0; i < nodes.length; i += 1) { - const node = nodes[i]; - if (node.nodeType === 3) { - node.data = '' + data; - return nodes.splice(i, 1)[0]; - } + set_current_component(parent_component) + } + let SvelteElement + if (typeof HTMLElement !== "undefined") { + SvelteElement = class extends HTMLElement { + constructor() { + super() + this.attachShadow({ mode: "open" }) + } + connectedCallback() { + // @ts-ignore todo: improve typings + for (const key in this.$$.slotted) { + // @ts-ignore todo: improve typings + this.appendChild(this.$$.slotted[key]) } - return text(data); - } - function claim_space(nodes) { - return claim_text(nodes, ' '); - } - function set_input_value(input, value) { - if (value != null || input.value) { - input.value = value; + } + attributeChangedCallback(attr, _oldValue, newValue) { + this[attr] = newValue + } + $destroy() { + destroy_component(this, 1) + this.$destroy = noop + } + $on(type, callback) { + // TODO should this delegate to addEventListener? + const callbacks = + this.$$.callbacks[type] || (this.$$.callbacks[type] = []) + callbacks.push(callback) + return () => { + const index = callbacks.indexOf(callback) + if (index !== -1) callbacks.splice(index, 1) } + } + $set() { + // overridden by instance, if it has props + } } - function set_style(node, key, value, important) { - node.style.setProperty(key, value, important ? 'important' : ''); + } + class SvelteComponent { + $destroy() { + destroy_component(this, 1) + this.$destroy = noop } - function toggle_class(element, name, toggle) { - element.classList[toggle ? 'add' : 'remove'](name); + $on(type, callback) { + const callbacks = + this.$$.callbacks[type] || (this.$$.callbacks[type] = []) + callbacks.push(callback) + return () => { + const index = callbacks.indexOf(callback) + if (index !== -1) callbacks.splice(index, 1) + } } - function custom_event(type, detail) { - const e = document.createEvent('CustomEvent'); - e.initCustomEvent(type, false, false, detail); - return e; + $set() { + // overridden by instance, if it has props } - - let current_component; - function set_current_component(component) { - current_component = component; + } + + function dispatch_dev(type, detail) { + document.dispatchEvent(custom_event(type, detail)) + } + function append_dev(target, node) { + dispatch_dev("SvelteDOMInsert", { target, node }) + append(target, node) + } + function insert_dev(target, node, anchor) { + dispatch_dev("SvelteDOMInsert", { target, node, anchor }) + insert(target, node, anchor) + } + function detach_dev(node) { + dispatch_dev("SvelteDOMRemove", { node }) + detach(node) + } + function listen_dev( + node, + event, + handler, + options, + has_prevent_default, + has_stop_propagation + ) { + const modifiers = + options === true + ? ["capture"] + : options + ? Array.from(Object.keys(options)) + : [] + if (has_prevent_default) modifiers.push("preventDefault") + if (has_stop_propagation) modifiers.push("stopPropagation") + dispatch_dev("SvelteDOMAddEventListener", { + node, + event, + handler, + modifiers, + }) + const dispose = listen(node, event, handler, options) + return () => { + dispatch_dev("SvelteDOMRemoveEventListener", { + node, + event, + handler, + modifiers, + }) + dispose() } - function get_current_component() { - if (!current_component) - throw new Error(`Function called outside component initialization`); - return current_component; + } + function attr_dev(node, attribute, value) { + attr(node, attribute, value) + if (value == null) + dispatch_dev("SvelteDOMRemoveAttribute", { node, attribute }) + else dispatch_dev("SvelteDOMSetAttribute", { node, attribute, value }) + } + function prop_dev(node, property, value) { + node[property] = value + dispatch_dev("SvelteDOMSetProperty", { node, property, value }) + } + function set_data_dev(text, data) { + data = "" + data + if (text.data === data) return + dispatch_dev("SvelteDOMSetData", { node: text, data }) + text.data = data + } + class SvelteComponentDev extends SvelteComponent { + constructor(options) { + if (!options || (!options.target && !options.$$inline)) { + throw new Error(`'target' is a required option`) + } + super() } - // TODO figure out if we still want to support - // shorthand events, or if we want to implement - // a real bubbling mechanism - function bubble(component, event) { - const callbacks = component.$$.callbacks[event.type]; - if (callbacks) { - callbacks.slice().forEach(fn => fn(event)); - } + $destroy() { + super.$destroy() + this.$destroy = () => { + console.warn(`Component was already destroyed`) // eslint-disable-line no-console + } } - - const dirty_components = []; - const binding_callbacks = []; - const render_callbacks = []; - const flush_callbacks = []; - const resolved_promise = Promise.resolve(); - let update_scheduled = false; - function schedule_update() { - if (!update_scheduled) { - update_scheduled = true; - resolved_promise.then(flush); + } + + const subscriber_queue = [] + /** + * Create a `Writable` store that allows both updating and reading by subscription. + * @param {*=}value initial value + * @param {StartStopNotifier=}start start and stop notifications for subscriptions + */ + function writable(value, start = noop) { + let stop + const subscribers = [] + function set(new_value) { + if (safe_not_equal(value, new_value)) { + value = new_value + if (stop) { + // store is ready + const run_queue = !subscriber_queue.length + for (let i = 0; i < subscribers.length; i += 1) { + const s = subscribers[i] + s[1]() + subscriber_queue.push(s, value) + } + if (run_queue) { + for (let i = 0; i < subscriber_queue.length; i += 2) { + subscriber_queue[i][0](subscriber_queue[i + 1]) + } + subscriber_queue.length = 0 + } } + } } - function add_render_callback(fn) { - render_callbacks.push(fn); + function update(fn) { + set(fn(value)) } - function flush() { - const seen_callbacks = new Set(); - do { - // first, call beforeUpdate functions - // and update components - while (dirty_components.length) { - const component = dirty_components.shift(); - set_current_component(component); - update(component.$$); - } - while (binding_callbacks.length) - binding_callbacks.pop()(); - // then, once components are updated, call - // afterUpdate functions. This may cause - // subsequent updates... - for (let i = 0; i < render_callbacks.length; i += 1) { - const callback = render_callbacks[i]; - if (!seen_callbacks.has(callback)) { - callback(); - // ...so guard against infinite loops - seen_callbacks.add(callback); - } - } - render_callbacks.length = 0; - } while (dirty_components.length); - while (flush_callbacks.length) { - flush_callbacks.pop()(); - } - update_scheduled = false; - } - function update($$) { - if ($$.fragment) { - $$.update($$.dirty); - run_all($$.before_update); - $$.fragment.p($$.dirty, $$.ctx); - $$.dirty = null; - $$.after_update.forEach(add_render_callback); - } - } - const outroing = new Set(); - let outros; - function group_outros() { - outros = { - r: 0, - c: [], - p: outros // parent group - }; - } - function check_outros() { - if (!outros.r) { - run_all(outros.c); - } - outros = outros.p; - } - function transition_in(block, local) { - if (block && block.i) { - outroing.delete(block); - block.i(local); - } - } - function transition_out(block, local, detach, callback) { - if (block && block.o) { - if (outroing.has(block)) - return; - outroing.add(block); - outros.c.push(() => { - outroing.delete(block); - if (callback) { - if (detach) - block.d(1); - callback(); - } - }); - block.o(local); - } - } - - function handle_promise(promise, info) { - const token = info.token = {}; - function update(type, index, key, value) { - if (info.token !== token) - return; - info.resolved = key && { [key]: value }; - const child_ctx = assign(assign({}, info.ctx), info.resolved); - const block = type && (info.current = type)(child_ctx); - if (info.block) { - if (info.blocks) { - info.blocks.forEach((block, i) => { - if (i !== index && block) { - group_outros(); - transition_out(block, 1, 1, () => { - info.blocks[i] = null; - }); - check_outros(); - } - }); - } - else { - info.block.d(1); - } - block.c(); - transition_in(block, 1); - block.m(info.mount(), info.anchor); - flush(); - } - info.block = block; - if (info.blocks) - info.blocks[index] = block; - } - if (is_promise(promise)) { - const current_component = get_current_component(); - promise.then(value => { - set_current_component(current_component); - update(info.then, 1, info.value, value); - set_current_component(null); - }, error => { - set_current_component(current_component); - update(info.catch, 2, info.error, error); - set_current_component(null); - }); - // if we previously had a then/catch block, destroy it - if (info.current !== info.pending) { - update(info.pending, 0); - return true; - } + function subscribe(run, invalidate = noop) { + const subscriber = [run, invalidate] + subscribers.push(subscriber) + if (subscribers.length === 1) { + stop = start(set) || noop + } + run(value) + return () => { + const index = subscribers.indexOf(subscriber) + if (index !== -1) { + subscribers.splice(index, 1) } - else { - if (info.current !== info.then) { - update(info.then, 1, info.value, promise); - return true; - } - info.resolved = { [info.value]: promise }; + if (subscribers.length === 0) { + stop() + stop = null } + } } + return { set, update, subscribe } + } - const globals = (typeof window !== 'undefined' ? window : global); - function mount_component(component, target, anchor) { - const { fragment, on_mount, on_destroy, after_update } = component.$$; - fragment.m(target, anchor); - // onMount happens before the initial afterUpdate - add_render_callback(() => { - const new_on_destroy = on_mount.map(run).filter(is_function); - if (on_destroy) { - on_destroy.push(...new_on_destroy); - } - else { - // Edge case - component was destroyed immediately, - // most likely as a result of a binding initialising - run_all(new_on_destroy); - } - component.$$.on_mount = []; - }); - after_update.forEach(add_render_callback); - } - function destroy_component(component, detaching) { - if (component.$$.fragment) { - run_all(component.$$.on_destroy); - component.$$.fragment.d(detaching); - // TODO null out other refs, including component.$$ (but need to - // preserve final state?) - component.$$.on_destroy = component.$$.fragment = null; - component.$$.ctx = {}; - } - } - function make_dirty(component, key) { - if (!component.$$.dirty) { - dirty_components.push(component); - schedule_update(); - component.$$.dirty = blank_object(); - } - component.$$.dirty[key] = true; - } - function init(component, options, instance, create_fragment, not_equal, prop_names) { - const parent_component = current_component; - set_current_component(component); - const props = options.props || {}; - const $$ = component.$$ = { - fragment: null, - ctx: null, - // state - props: prop_names, - update: noop, - not_equal, - bound: blank_object(), - // lifecycle - on_mount: [], - on_destroy: [], - before_update: [], - after_update: [], - context: new Map(parent_component ? parent_component.$$.context : []), - // everything else - callbacks: blank_object(), - dirty: null - }; - let ready = false; - $$.ctx = instance - ? instance(component, props, (key, ret, value = ret) => { - if ($$.ctx && not_equal($$.ctx[key], $$.ctx[key] = value)) { - if ($$.bound[key]) - $$.bound[key](value); - if (ready) - make_dirty(component, key); - } - return ret; - }) - : props; - $$.update(); - ready = true; - run_all($$.before_update); - $$.fragment = create_fragment($$.ctx); - if (options.target) { - if (options.hydrate) { - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - $$.fragment.l(children(options.target)); - } - else { - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - $$.fragment.c(); - } - if (options.intro) - transition_in(component.$$.fragment); - mount_component(component, options.target, options.anchor); - flush(); - } - set_current_component(parent_component); - } - let SvelteElement; - if (typeof HTMLElement !== 'undefined') { - SvelteElement = class extends HTMLElement { - constructor() { - super(); - this.attachShadow({ mode: 'open' }); - } - connectedCallback() { - // @ts-ignore todo: improve typings - for (const key in this.$$.slotted) { - // @ts-ignore todo: improve typings - this.appendChild(this.$$.slotted[key]); - } - } - attributeChangedCallback(attr, _oldValue, newValue) { - this[attr] = newValue; - } - $destroy() { - destroy_component(this, 1); - this.$destroy = noop; - } - $on(type, callback) { - // TODO should this delegate to addEventListener? - const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = [])); - callbacks.push(callback); - return () => { - const index = callbacks.indexOf(callback); - if (index !== -1) - callbacks.splice(index, 1); - }; - } - $set() { - // overridden by instance, if it has props - } - }; - } - class SvelteComponent { - $destroy() { - destroy_component(this, 1); - this.$destroy = noop; - } - $on(type, callback) { - const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = [])); - callbacks.push(callback); - return () => { - const index = callbacks.indexOf(callback); - if (index !== -1) - callbacks.splice(index, 1); - }; - } - $set() { - // overridden by instance, if it has props - } - } - - function dispatch_dev(type, detail) { - document.dispatchEvent(custom_event(type, detail)); - } - function append_dev(target, node) { - dispatch_dev("SvelteDOMInsert", { target, node }); - append(target, node); - } - function insert_dev(target, node, anchor) { - dispatch_dev("SvelteDOMInsert", { target, node, anchor }); - insert(target, node, anchor); - } - function detach_dev(node) { - dispatch_dev("SvelteDOMRemove", { node }); - detach(node); - } - function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) { - const modifiers = options === true ? ["capture"] : options ? Array.from(Object.keys(options)) : []; - if (has_prevent_default) - modifiers.push('preventDefault'); - if (has_stop_propagation) - modifiers.push('stopPropagation'); - dispatch_dev("SvelteDOMAddEventListener", { node, event, handler, modifiers }); - const dispose = listen(node, event, handler, options); - return () => { - dispatch_dev("SvelteDOMRemoveEventListener", { node, event, handler, modifiers }); - dispose(); - }; - } - function attr_dev(node, attribute, value) { - attr(node, attribute, value); - if (value == null) - dispatch_dev("SvelteDOMRemoveAttribute", { node, attribute }); - else - dispatch_dev("SvelteDOMSetAttribute", { node, attribute, value }); - } - function prop_dev(node, property, value) { - node[property] = value; - dispatch_dev("SvelteDOMSetProperty", { node, property, value }); - } - function set_data_dev(text, data) { - data = '' + data; - if (text.data === data) - return; - dispatch_dev("SvelteDOMSetData", { node: text, data }); - text.data = data; - } - class SvelteComponentDev extends SvelteComponent { - constructor(options) { - if (!options || (!options.target && !options.$$inline)) { - throw new Error(`'target' is a required option`); - } - super(); + /* src\Textbox.svelte generated by Svelte v3.12.1 */ + + const file = "src\\Textbox.svelte" + + // (32:0) {:else} + function create_else_block(ctx) { + var input, input_class_value + + const block = { + c: function create() { + input = element("input") + this.h() + }, + + l: function claim(nodes) { + input = claim_element( + nodes, + "INPUT", + { class: true, type: true, value: true }, + false + ) + var input_nodes = children(input) + + input_nodes.forEach(detach_dev) + this.h() + }, + + h: function hydrate() { + attr_dev( + input, + "class", + (input_class_value = + "" + null_to_empty(ctx.className) + " svelte-1ec4wqj") + ) + attr_dev(input, "type", "text") + input.value = ctx.actualValue + add_location(input, file, 32, 0, 546) + }, + + m: function mount(target, anchor) { + insert_dev(target, input, anchor) + }, + + p: function update(changed, ctx) { + if ( + changed.className && + input_class_value !== + (input_class_value = + "" + null_to_empty(ctx.className) + " svelte-1ec4wqj") + ) { + attr_dev(input, "class", input_class_value) } - $destroy() { - super.$destroy(); - this.$destroy = () => { - console.warn(`Component was already destroyed`); // eslint-disable-line no-console - }; + + if (changed.actualValue) { + prop_dev(input, "value", ctx.actualValue) + } + }, + + d: function destroy(detaching) { + if (detaching) { + detach_dev(input) } + }, } + dispatch_dev("SvelteRegisterBlock", { + block, + id: create_else_block.name, + type: "else", + source: "(32:0) {:else}", + ctx, + }) + return block + } + + // (28:0) {#if hideValue} + function create_if_block(ctx) { + var input, input_class_value, dispose + + const block = { + c: function create() { + input = element("input") + this.h() + }, - const subscriber_queue = []; - /** - * Create a `Writable` store that allows both updating and reading by subscription. - * @param {*=}value initial value - * @param {StartStopNotifier=}start start and stop notifications for subscriptions - */ - function writable(value, start = noop) { - let stop; - const subscribers = []; - function set(new_value) { - if (safe_not_equal(value, new_value)) { - value = new_value; - if (stop) { // store is ready - const run_queue = !subscriber_queue.length; - for (let i = 0; i < subscribers.length; i += 1) { - const s = subscribers[i]; - s[1](); - subscriber_queue.push(s, value); - } - if (run_queue) { - for (let i = 0; i < subscriber_queue.length; i += 2) { - subscriber_queue[i][0](subscriber_queue[i + 1]); - } - subscriber_queue.length = 0; - } - } - } + l: function claim(nodes) { + input = claim_element( + nodes, + "INPUT", + { class: true, type: true, value: true }, + false + ) + var input_nodes = children(input) + + input_nodes.forEach(detach_dev) + this.h() + }, + + h: function hydrate() { + attr_dev( + input, + "class", + (input_class_value = + "" + null_to_empty(ctx.className) + " svelte-1ec4wqj") + ) + attr_dev(input, "type", "password") + input.value = ctx.actualValue + add_location(input, file, 28, 0, 455) + dispose = listen_dev(input, "change", ctx.change_handler) + }, + + m: function mount(target, anchor) { + insert_dev(target, input, anchor) + }, + + p: function update(changed, ctx) { + if ( + changed.className && + input_class_value !== + (input_class_value = + "" + null_to_empty(ctx.className) + " svelte-1ec4wqj") + ) { + attr_dev(input, "class", input_class_value) } - function update(fn) { - set(fn(value)); + + if (changed.actualValue) { + prop_dev(input, "value", ctx.actualValue) + } + }, + + d: function destroy(detaching) { + if (detaching) { + detach_dev(input) } - function subscribe(run, invalidate = noop) { - const subscriber = [run, invalidate]; - subscribers.push(subscriber); - if (subscribers.length === 1) { - stop = start(set) || noop; - } - run(value); - return () => { - const index = subscribers.indexOf(subscriber); - if (index !== -1) { - subscribers.splice(index, 1); - } - if (subscribers.length === 0) { - stop(); - stop = null; - } - }; - } - return { set, update, subscribe }; - } - - /* src\Textbox.svelte generated by Svelte v3.12.1 */ - - const file = "src\\Textbox.svelte"; - - // (32:0) {:else} - function create_else_block(ctx) { - var input, input_class_value; - - const block = { - c: function create() { - input = element("input"); - this.h(); - }, - - l: function claim(nodes) { - input = claim_element(nodes, "INPUT", { class: true, type: true, value: true }, false); - var input_nodes = children(input); - - input_nodes.forEach(detach_dev); - this.h(); - }, - - h: function hydrate() { - attr_dev(input, "class", input_class_value = "" + null_to_empty(ctx.className) + " svelte-1ec4wqj"); - attr_dev(input, "type", "text"); - input.value = ctx.actualValue; - add_location(input, file, 32, 0, 546); - }, - - m: function mount(target, anchor) { - insert_dev(target, input, anchor); - }, - - p: function update(changed, ctx) { - if ((changed.className) && input_class_value !== (input_class_value = "" + null_to_empty(ctx.className) + " svelte-1ec4wqj")) { - attr_dev(input, "class", input_class_value); - } - - if (changed.actualValue) { - prop_dev(input, "value", ctx.actualValue); - } - }, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(input); - } - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_else_block.name, type: "else", source: "(32:0) {:else}", ctx }); - return block; - } - - // (28:0) {#if hideValue} - function create_if_block(ctx) { - var input, input_class_value, dispose; - - const block = { - c: function create() { - input = element("input"); - this.h(); - }, - - l: function claim(nodes) { - input = claim_element(nodes, "INPUT", { class: true, type: true, value: true }, false); - var input_nodes = children(input); - - input_nodes.forEach(detach_dev); - this.h(); - }, - - h: function hydrate() { - attr_dev(input, "class", input_class_value = "" + null_to_empty(ctx.className) + " svelte-1ec4wqj"); - attr_dev(input, "type", "password"); - input.value = ctx.actualValue; - add_location(input, file, 28, 0, 455); - dispose = listen_dev(input, "change", ctx.change_handler); - }, - - m: function mount(target, anchor) { - insert_dev(target, input, anchor); - }, - - p: function update(changed, ctx) { - if ((changed.className) && input_class_value !== (input_class_value = "" + null_to_empty(ctx.className) + " svelte-1ec4wqj")) { - attr_dev(input, "class", input_class_value); - } - - if (changed.actualValue) { - prop_dev(input, "value", ctx.actualValue); - } - }, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(input); - } - - dispose(); - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_if_block.name, type: "if", source: "(28:0) {#if hideValue}", ctx }); - return block; - } - - function create_fragment(ctx) { - var if_block_anchor; - - function select_block_type(changed, ctx) { - if (ctx.hideValue) return create_if_block; - return create_else_block; - } - - var current_block_type = select_block_type(null, ctx); - var if_block = current_block_type(ctx); - - const block = { - c: function create() { - if_block.c(); - if_block_anchor = empty(); - }, - - l: function claim(nodes) { - if_block.l(nodes); - if_block_anchor = empty(); - }, - - m: function mount(target, anchor) { - if_block.m(target, anchor); - insert_dev(target, if_block_anchor, anchor); - }, - - p: function update(changed, ctx) { - if (current_block_type === (current_block_type = select_block_type(changed, ctx)) && if_block) { - if_block.p(changed, ctx); - } else { - if_block.d(1); - if_block = current_block_type(ctx); - if (if_block) { - if_block.c(); - if_block.m(if_block_anchor.parentNode, if_block_anchor); - } - } - }, - - i: noop, - o: noop, - - d: function destroy(detaching) { - if_block.d(detaching); - - if (detaching) { - detach_dev(if_block_anchor); - } - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_fragment.name, type: "component", source: "", ctx }); - return block; - } - - function instance($$self, $$props, $$invalidate) { - let { value="", hideValue = false, className = "default", _bb } = $$props; - - let actualValue = ""; - - const writable_props = ['value', 'hideValue', 'className', '_bb']; - Object.keys($$props).forEach(key => { - if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(` was created with unknown prop '${key}'`); - }); - - function change_handler(event) { - bubble($$self, event); - } - - $$self.$set = $$props => { - if ('value' in $$props) $$invalidate('value', value = $$props.value); - if ('hideValue' in $$props) $$invalidate('hideValue', hideValue = $$props.hideValue); - if ('className' in $$props) $$invalidate('className', className = $$props.className); - if ('_bb' in $$props) $$invalidate('_bb', _bb = $$props._bb); - }; - - $$self.$capture_state = () => { - return { value, hideValue, className, _bb, actualValue }; - }; - - $$self.$inject_state = $$props => { - if ('value' in $$props) $$invalidate('value', value = $$props.value); - if ('hideValue' in $$props) $$invalidate('hideValue', hideValue = $$props.hideValue); - if ('className' in $$props) $$invalidate('className', className = $$props.className); - if ('_bb' in $$props) $$invalidate('_bb', _bb = $$props._bb); - if ('actualValue' in $$props) $$invalidate('actualValue', actualValue = $$props.actualValue); - }; - - $$self.$$.update = ($$dirty = { _bb: 1, value: 1 }) => { - if ($$dirty._bb || $$dirty.value) { { - if(_bb && value._isstate) { - _bb.store.subscribe(s => { - $$invalidate('actualValue', actualValue = _bb.store.getValue(s, value)); - }); - } - } } - }; - - return { - value, - hideValue, - className, - _bb, - actualValue, - change_handler - }; - } - - class Textbox extends SvelteComponentDev { - constructor(options) { - super(options); - init(this, options, instance, create_fragment, safe_not_equal, ["value", "hideValue", "className", "_bb"]); - dispatch_dev("SvelteRegisterComponent", { component: this, tagName: "Textbox", options, id: create_fragment.name }); - - const { ctx } = this.$$; - const props = options.props || {}; - if (ctx._bb === undefined && !('_bb' in props)) { - console.warn(" was created without expected prop '_bb'"); - } - } - - get value() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set value(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - - get hideValue() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set hideValue(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - - get className() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set className(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - - get _bb() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set _bb(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - } - - /* src\Form.svelte generated by Svelte v3.12.1 */ - - const file$1 = "src\\Form.svelte"; - - function get_each_context(ctx, list, i) { - const child_ctx = Object.create(ctx); - child_ctx.child = list[i]; - child_ctx.index = i; - return child_ctx; - } - - // (30:4) {#each formControls as child, index} - function create_each_block(ctx) { - var div0, t0_value = ctx.labels[ctx.index] + "", t0, t1, div1, index = ctx.index; - - const assign_div1 = () => ctx.div1_binding(div1, index); - const unassign_div1 = () => ctx.div1_binding(null, index); - - const block = { - c: function create() { - div0 = element("div"); - t0 = text(t0_value); - t1 = space(); - div1 = element("div"); - this.h(); - }, - - l: function claim(nodes) { - div0 = claim_element(nodes, "DIV", { class: true }, false); - var div0_nodes = children(div0); - - t0 = claim_text(div0_nodes, t0_value); - div0_nodes.forEach(detach_dev); - t1 = claim_space(nodes); - - div1 = claim_element(nodes, "DIV", { class: true }, false); - var div1_nodes = children(div1); - - div1_nodes.forEach(detach_dev); - this.h(); - }, - - h: function hydrate() { - attr_dev(div0, "class", "label svelte-m9d6ue"); - add_location(div0, file$1, 30, 4, 559); - attr_dev(div1, "class", "control svelte-m9d6ue"); - add_location(div1, file$1, 31, 4, 604); - }, - - m: function mount(target, anchor) { - insert_dev(target, div0, anchor); - append_dev(div0, t0); - insert_dev(target, t1, anchor); - insert_dev(target, div1, anchor); - assign_div1(); - }, - - p: function update(changed, new_ctx) { - ctx = new_ctx; - if ((changed.labels) && t0_value !== (t0_value = ctx.labels[ctx.index] + "")) { - set_data_dev(t0, t0_value); - } - - if (index !== ctx.index) { - unassign_div1(); - index = ctx.index; - assign_div1(); - } - }, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(div0); - detach_dev(t1); - detach_dev(div1); - } - - unassign_div1(); - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_each_block.name, type: "each", source: "(30:4) {#each formControls as child, index}", ctx }); - return block; - } - - function create_fragment$1(ctx) { - var div, div_class_value; - - let each_value = ctx.formControls; - - let each_blocks = []; - - for (let i = 0; i < each_value.length; i += 1) { - each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); - } - - const block = { - c: function create() { - div = element("div"); - - for (let i = 0; i < each_blocks.length; i += 1) { - each_blocks[i].c(); - } - this.h(); - }, - - l: function claim(nodes) { - div = claim_element(nodes, "DIV", { class: true }, false); - var div_nodes = children(div); - - for (let i = 0; i < each_blocks.length; i += 1) { - each_blocks[i].l(div_nodes); - } - - div_nodes.forEach(detach_dev); - this.h(); - }, - - h: function hydrate() { - attr_dev(div, "class", div_class_value = "form-root " + ctx.containerClass + " svelte-m9d6ue"); - add_location(div, file$1, 28, 0, 473); - }, - - m: function mount(target, anchor) { - insert_dev(target, div, anchor); - - for (let i = 0; i < each_blocks.length; i += 1) { - each_blocks[i].m(div, null); - } - }, - - p: function update(changed, ctx) { - if (changed.htmlElements || changed.labels || changed.formControls) { - each_value = ctx.formControls; - - let i; - for (i = 0; i < each_value.length; i += 1) { - const child_ctx = get_each_context(ctx, each_value, i); - - if (each_blocks[i]) { - each_blocks[i].p(changed, child_ctx); - } else { - each_blocks[i] = create_each_block(child_ctx); - each_blocks[i].c(); - each_blocks[i].m(div, null); - } - } - - for (; i < each_blocks.length; i += 1) { - each_blocks[i].d(1); - } - each_blocks.length = each_value.length; - } - - if ((changed.containerClass) && div_class_value !== (div_class_value = "form-root " + ctx.containerClass + " svelte-m9d6ue")) { - attr_dev(div, "class", div_class_value); - } - }, - - i: noop, - o: noop, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(div); - } - - destroy_each(each_blocks, detaching); - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_fragment$1.name, type: "component", source: "", ctx }); - return block; - } - - function instance$1($$self, $$props, $$invalidate) { - let { containerClass = "", formControls = [], _bb } = $$props; - - let htmlElements = {}; - let labels = {}; - - const writable_props = ['containerClass', 'formControls', '_bb']; - Object.keys($$props).forEach(key => { - if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`
was created with unknown prop '${key}'`); - }); - - function div1_binding($$value, index) { - if (htmlElements[index] === $$value) return; - binding_callbacks[$$value ? 'unshift' : 'push'](() => { - htmlElements[index] = $$value; - $$invalidate('htmlElements', htmlElements); - }); - } - - $$self.$set = $$props => { - if ('containerClass' in $$props) $$invalidate('containerClass', containerClass = $$props.containerClass); - if ('formControls' in $$props) $$invalidate('formControls', formControls = $$props.formControls); - if ('_bb' in $$props) $$invalidate('_bb', _bb = $$props._bb); - }; - - $$self.$capture_state = () => { - return { containerClass, formControls, _bb, htmlElements, labels }; - }; - - $$self.$inject_state = $$props => { - if ('containerClass' in $$props) $$invalidate('containerClass', containerClass = $$props.containerClass); - if ('formControls' in $$props) $$invalidate('formControls', formControls = $$props.formControls); - if ('_bb' in $$props) $$invalidate('_bb', _bb = $$props._bb); - if ('htmlElements' in $$props) $$invalidate('htmlElements', htmlElements = $$props.htmlElements); - if ('labels' in $$props) $$invalidate('labels', labels = $$props.labels); - }; - - $$self.$$.update = ($$dirty = { formControls: 1, _bb: 1, htmlElements: 1 }) => { - if ($$dirty.formControls || $$dirty._bb || $$dirty.htmlElements) { { - let cIndex = 0; - for(let c of formControls) { - $$invalidate('labels', labels[cIndex] = c.label, labels); - cIndex++; - } - - if(_bb && htmlElements) { - for(let el in htmlElements) { - _bb.initialiseComponent( - formControls[el].control, - htmlElements[el] - ); - } - } - } } - }; - - return { - containerClass, - formControls, - _bb, - htmlElements, - labels, - div1_binding - }; - } - - class Form extends SvelteComponentDev { - constructor(options) { - super(options); - init(this, options, instance$1, create_fragment$1, safe_not_equal, ["containerClass", "formControls", "_bb"]); - dispatch_dev("SvelteRegisterComponent", { component: this, tagName: "Form", options, id: create_fragment$1.name }); - - const { ctx } = this.$$; - const props = options.props || {}; - if (ctx._bb === undefined && !('_bb' in props)) { - console.warn(" was created without expected prop '_bb'"); - } - } - - get containerClass() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set containerClass(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - - get formControls() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set formControls(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - - get _bb() { - throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''"); - } - - set _bb(value) { - throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''"); - } - } - - /* src\Button.svelte generated by Svelte v3.12.1 */ - - const file$2 = "src\\Button.svelte"; - - // (30:4) {:else} - function create_else_block$1(ctx) { - var current; - - const default_slot_template = ctx.$$slots.default; - const default_slot = create_slot(default_slot_template, ctx, null); - - const block = { - c: function create() { - if (default_slot) default_slot.c(); - }, - - l: function claim(nodes) { - if (default_slot) default_slot.l(nodes); - }, - - m: function mount(target, anchor) { - if (default_slot) { - default_slot.m(target, anchor); - } - - current = true; - }, - - p: function update(changed, ctx) { - if (default_slot && default_slot.p && changed.$$scope) { - default_slot.p( - get_slot_changes(default_slot_template, ctx, changed, null), - get_slot_context(default_slot_template, ctx, null) - ); - } - }, - - i: function intro(local) { - if (current) return; - transition_in(default_slot, local); - current = true; - }, - - o: function outro(local) { - transition_out(default_slot, local); - current = false; - }, - - d: function destroy(detaching) { - if (default_slot) default_slot.d(detaching); - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_else_block$1.name, type: "else", source: "(30:4) {:else}", ctx }); - return block; - } - - // (28:26) - function create_if_block_1(ctx) { - var t; - - const block = { - c: function create() { - t = text(ctx.contentText); - }, - - l: function claim(nodes) { - t = claim_text(nodes, ctx.contentText); - }, - - m: function mount(target, anchor) { - insert_dev(target, t, anchor); - }, - - p: function update(changed, ctx) { - if (changed.contentText) { - set_data_dev(t, ctx.contentText); - } - }, - - i: noop, - o: noop, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(t); - } - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_if_block_1.name, type: "if", source: "(28:26) ", ctx }); - return block; - } - - // (25:4) {#if contentComponent && contentComponent._component} - function create_if_block$1(ctx) { - var div; - - const block = { - c: function create() { - div = element("div"); - this.h(); - }, - - l: function claim(nodes) { - div = claim_element(nodes, "DIV", {}, false); - var div_nodes = children(div); - - div_nodes.forEach(detach_dev); - this.h(); - }, - - h: function hydrate() { - add_location(div, file$2, 25, 1, 543); - }, - - m: function mount(target, anchor) { - insert_dev(target, div, anchor); - ctx.div_binding(div); - }, - - p: noop, - i: noop, - o: noop, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(div); - } - - ctx.div_binding(null); - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_if_block$1.name, type: "if", source: "(25:4) {#if contentComponent && contentComponent._component}", ctx }); - return block; - } - - function create_fragment$2(ctx) { - var button, current_block_type_index, if_block, button_class_value, current, dispose; - - var if_block_creators = [ - create_if_block$1, - create_if_block_1, - create_else_block$1 - ]; - - var if_blocks = []; - - function select_block_type(changed, ctx) { - if (ctx.contentComponent && ctx.contentComponent._component) return 0; - if (ctx.contentText) return 1; - return 2; - } - - current_block_type_index = select_block_type(null, ctx); - if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); - - const block = { - c: function create() { - button = element("button"); - if_block.c(); - this.h(); - }, - - l: function claim(nodes) { - button = claim_element(nodes, "BUTTON", { class: true, disabled: true }, false); - var button_nodes = children(button); - - if_block.l(button_nodes); - button_nodes.forEach(detach_dev); - this.h(); - }, - - h: function hydrate() { - attr_dev(button, "class", button_class_value = "" + null_to_empty(ctx.className) + " svelte-1q8lga0"); - button.disabled = ctx.disabled; - add_location(button, file$2, 23, 0, 422); - dispose = listen_dev(button, "click", ctx.clickHandler); - }, - - m: function mount(target, anchor) { - insert_dev(target, button, anchor); - if_blocks[current_block_type_index].m(button, null); - current = true; - }, - - p: function update(changed, ctx) { - var previous_block_index = current_block_type_index; - current_block_type_index = select_block_type(changed, ctx); - if (current_block_type_index === previous_block_index) { - if_blocks[current_block_type_index].p(changed, ctx); - } else { - group_outros(); - transition_out(if_blocks[previous_block_index], 1, 1, () => { - if_blocks[previous_block_index] = null; - }); - check_outros(); - - if_block = if_blocks[current_block_type_index]; - if (!if_block) { - if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); - if_block.c(); - } - transition_in(if_block, 1); - if_block.m(button, null); - } - - if ((!current || changed.className) && button_class_value !== (button_class_value = "" + null_to_empty(ctx.className) + " svelte-1q8lga0")) { - attr_dev(button, "class", button_class_value); - } - - if (!current || changed.disabled) { - prop_dev(button, "disabled", ctx.disabled); - } - }, - - i: function intro(local) { - if (current) return; - transition_in(if_block); - current = true; - }, - - o: function outro(local) { - transition_out(if_block); - current = false; - }, - - d: function destroy(detaching) { - if (detaching) { - detach_dev(button); - } - - if_blocks[current_block_type_index].d(); - dispose(); - } - }; - dispatch_dev("SvelteRegisterBlock", { block, id: create_fragment$2.name, type: "component", source: "", ctx }); - return block; - } - - function instance$2($$self, $$props, $$invalidate) { - let { className = "default", disabled = false, contentText, contentComponent, onClick = () => {} } = $$props; - - let { _bb } = $$props; - let contentComponentContainer; + dispose() + }, + } + dispatch_dev("SvelteRegisterBlock", { + block, + id: create_if_block.name, + type: "if", + source: "(28:0) {#if hideValue}", + ctx, + }) + return block + } + + function create_fragment(ctx) { + var if_block_anchor + + function select_block_type(changed, ctx) { + if (ctx.hideValue) return create_if_block + return create_else_block + } - const clickHandler = () => { - if(onClick) onClick(); - }; - - const writable_props = ['className', 'disabled', 'contentText', 'contentComponent', 'onClick', '_bb']; - Object.keys($$props).forEach(key => { - if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`