@ohos-ports/focuson-lenstest 1.44.3-beta.1

package/dist/src/lenspath.spec.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lens_1 = require("@focuson/lens");
+describe('tokenisepath', () => {
+    it("should extract the prefix as a token, replacing 'no prefix with ''", () => {
+        expect((0, lens_1.tokenisePath)('a')).toEqual(['a']);
+        expect((0, lens_1.tokenisePath)('a/b')).toEqual(['a', '/', 'b']);
+        expect((0, lens_1.tokenisePath)('one/two/three')).toEqual(['one', '/', 'two', '/', 'three']);
+        expect((0, lens_1.tokenisePath)('/one/two/three')).toEqual(['/', 'one', '/', 'two', '/', 'three']);
+        expect((0, lens_1.tokenisePath)('~one/two/three')).toEqual(['~', 'one', '/', 'two', '/', 'three']);
+        expect((0, lens_1.tokenisePath)('')).toEqual([]);
+        expect((0, lens_1.tokenisePath)('/')).toEqual(['/']);
+        expect((0, lens_1.tokenisePath)('~')).toEqual(['~']);
+        expect((0, lens_1.tokenisePath)('$variable')).toEqual(['$variable']); // no prefix
+        expect((0, lens_1.tokenisePath)("/one[$var]")).toEqual(["/", "one", "$var"]);
+    });
+    it("should tokenise [ ... ] with simple content", () => {
+        expect((0, lens_1.tokenisePath)('/one[a]/two[b]/three[c]')).toEqual([
+            "/", "one", "[", "a", "]", "/", "two", "[", "b", "]", "/", "three", "[", "c", "]"
+        ]);
+    });
+    it("should tokenise [ ... ] with numbers", () => {
+        expect((0, lens_1.tokenisePath)('/one[1]/two[2]/three[3]')).toEqual([
+            "/", "one", "$1", "/", "two", "$2", "/", "three", "$3"
+        ]);
+    });
+    it("should tokenise [ ... ] with $tokens", () => {
+        expect((0, lens_1.tokenisePath)('/a[$one]/bb[$two]/ccc[$three]')).toEqual([
+            "/", "a", "$one", "/", "bb", "$two", "/", "ccc", "$three"
+        ]);
+    });
+    it("should tokenise [ ... ] with path in the []", () => {
+        expect((0, lens_1.tokenisePath)('/one[a/b]/two[/bbb/ccc]/three[~/ccc]')).toEqual([
+            "/", "one", "[", "a", "/", "b", "]", "/", "two", "[", "/", "bbb", "/", "ccc", "]", "/", "three", "[", "~", "/", "ccc", "]"
+        ]);
+    });
+    it("should tokenise [ ... ] with path in the [] and a $ or two", () => {
+        expect((0, lens_1.tokenisePath)('/one[$next]/two[bbb/ccc]/three[~/ccc][$next]')).toEqual([
+            "/", "one", "$next", "/", "two", "[", "bbb", "/", "ccc", "]", "/", "three", "[", "~", "/", "ccc", "]", "$next"
+        ]);
+    });
+    it("should tokenise the common usages of #", () => {
+        expect((0, lens_1.tokenisePath)('#variable')).toEqual(["#variable"]);
+        expect((0, lens_1.tokenisePath)('#var1[#var2]')).toEqual(["#var1", "[", "#var2", "]"]);
+    });
+});
+const stringBuilder = {
+    initialVariable(name) { return `initialV(${name})`; },
+    isVariable(name) { return !name.match(/^[0-9]+$/); },
+    foldVariable(acc, name) { return acc + `.variable(${name})`; },
+    zero(initial) { return `#${initial}#`; },
+    foldAppend(acc) { return acc + '.APPEND'; },
+    foldLast(acc) { return acc + '.LAST'; },
+    foldNth(acc, n) { return acc + `.[${n}]`; },
+    foldBracketsPath(acc, path) { return acc + '.OPEN[' + path + ']CLOSE'; },
+    foldKey(acc, key) { return acc + '.' + key; }
+};
+describe("parsePath", () => {
+    it("should fold the tokens", () => {
+        expect((0, lens_1.parsePath)('/one[$last]/two[bbb/ccc]/three[~/ccc][1][$append]/[#var]', stringBuilder)).toEqual('#/#.one.LAST.two.OPEN[##.bbb.ccc]CLOSE.three.OPEN[#~#.ccc]CLOSE.[1].APPEND.OPEN[initialV(var)]CLOSE');
+    });
+    it("should fold 'just a variable name'", () => {
+        expect((0, lens_1.parsePath)('#name', stringBuilder)).toEqual('initialV(name)');
+    });
+    it("should fold '#var1[#var2]", () => {
+        expect((0, lens_1.parsePath)('#var1[#var2]', stringBuilder)).toEqual('initialV(var1).OPEN[initialV(var2)]CLOSE');
+    });
+});
+const someData = {
+    a: {
+        b: {
+            c: 'cValue', d: 'dValue',
+        },
+        e: ['zero', 'one'],
+        v0: 0,
+        v1: 1,
+        vc: 'c',
+        vd: 'd',
+        vfalse: false,
+        vtrue: true
+    }
+};
+const id = lens_1.Lenses.identity();
+function makeAbL(path) {
+    return id.focusQuery('a').focusQuery('b').chainCalc(path);
+}
+function makeAEL(path) {
+    return id.focusQuery('a').focusQuery('e').chainCalc(path);
+}
+describe("calculateNth", () => {
+    it("should use the data at the end of  pathL as an index into first - string", () => {
+        expect(makeAbL(id.focusQuery('a').focusQuery('vc')).getOption(someData)).toEqual('cValue');
+        expect(makeAbL(id.focusQuery('a').focusQuery('vd')).getOption(someData)).toEqual('dValue');
+    });
+    it("should use the data at the end of  pathL as an index into first - numbers", () => {
+        expect(makeAEL(id.focusQuery('a').focusQuery('v0')).getOption(someData)).toEqual('zero');
+        expect(makeAEL(id.focusQuery('a').focusQuery('v1')).getOption(someData)).toEqual('one');
+    });
+    it("should use the data at the end of  pathL as an index into first - boolean", () => {
+        expect(makeAEL(id.focusQuery('a').focusQuery('vfalse')).getOption(someData)).toEqual('zero');
+        expect(makeAEL(id.focusQuery('a').focusQuery('vtrue')).getOption(someData)).toEqual('one');
+    });
+});
+describe("chainIntoArray", () => {
+    function makeLens(fn) { return fn(id.focusQuery('a')).chainIntoArray(['x', 'y', 'z']); }
+    const data = { a: { v0: 0, v1: 1, vt: true, vf: false }, b: 'stuff' };
+    it("should make an optional that uses the value focused on to select an element of an array", () => {
+        expect(makeLens(s => s.focusQuery('v0')).getOption(data)).toEqual('x');
+        expect(makeLens(s => s.focusQuery('v0')).setOption(data, 'y')).toEqual({ "a": { "v0": 1, "v1": 1, "vf": false, "vt": true }, "b": "stuff" });
+        expect(makeLens(s => s.focusQuery('v1')).getOption(data)).toEqual('y');
+        expect(makeLens(s => s.focusQuery('v1')).setOption(data, 'z')).toEqual({ "a": { "v0": 0, "v1": 2, "vf": false, "vt": true }, "b": "stuff" });
+        expect(makeLens(s => s.focusQuery('vt')).getOption(data)).toEqual('y');
+        expect(makeLens(s => s.focusQuery('vt')).setOption(data, 'x')).toEqual({ "a": { "v0": 0, "v1": 1, "vf": false, "vt": 0 }, "b": "stuff" });
+        expect(makeLens(s => s.focusQuery('vf')).getOption(data)).toEqual('x');
+        expect(makeLens(s => s.focusQuery('vf')).setOption(data, 'y')).toEqual({ "a": { "v0": 0, "v1": 1, "vf": 1, "vt": true }, "b": "stuff" });
+        expect(makeLens(s => s.focusQuery('vf')).description).toEqual("chainIntoArray(x,y,z)");
+    });
+});
+describe("parsePathMakingLens", () => {
+    const optionals = {
+        a: l => l.focusQuery('a'),
+        b: l => l.focusQuery('a').focusQuery('b'),
+    };
+    it("should make an optional", () => {
+        expect((0, lens_1.parsePath)('/', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I');
+        expect((0, lens_1.parsePath)('/a/v0', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).focus?(v0)');
+        expect((0, lens_1.parsePath)('/a/$last', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).chain([last])');
+        expect((0, lens_1.parsePath)('/a/$append', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).chain([append])');
+        expect((0, lens_1.parsePath)('/a/[1]', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).chain([1])');
+        expect((0, lens_1.parsePath)('/a/[/a/b]', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).chainCalc(I.focus?(a).focus?(b))');
+        expect((0, lens_1.parsePath)('/a/[b]', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(['', id.focusQuery('a')]), optionals)).description).toEqual('I.focus?(a).chainCalc(I.focus?(a).focus?(b))');
+        // expect ( parsePath ( '', lensBuilder ( prefixNameAndLens () ) ) ).toEqual ( undefined )
+    });
+    it("should throw error if the initial  isn't defined", () => {
+        expect(() => (0, lens_1.parsePath)('a/b', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals))).toThrow("Error parsing 'a/b'. Cannot find initial  ''");
+    });
+    it("should use variables", () => {
+        expect((0, lens_1.parsePath)('/a/#b', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).chain(I.focus?(a).focus?(b))');
+        expect((0, lens_1.parsePath)('/a/#a', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).chain(I.focus?(a))');
+        expect((0, lens_1.parsePath)('#a', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a)');
+        expect((0, lens_1.parsePath)('#b', (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals)).description).toEqual('I.focus?(a).focus?(b)');
+    });
+    it("should work in the style $currentOccupation[$selected]/occupation", () => {
+        const data = {
+            cur: [{ occupation: 'zero' }, { occupation: 'one' }],
+            selected: 1
+        };
+        const optionals = {
+            currentOccupation: l => l.focusQuery('cur'),
+            selected: l => l.focusQuery('selected')
+        };
+        let builder = (0, lens_1.lensBuilder)((0, lens_1.prefixNameAndLens)(), optionals);
+        expect((0, lens_1.tokenisePath)('#currentOccupation[#selected]/occupation')).toEqual([
+            "#currentOccupation", "[", "#selected", "]", "/", "occupation"
+        ]);
+        let lens = (0, lens_1.parsePath)('#currentOccupation[#selected]/occupation', builder);
+        expect(lens.description).toEqual('I.focus?(cur).chainCalc(I.focus?(selected)).focus?(occupation)');
+        expect(lens.getOption(data)).toEqual('one');
+    });
+});
+describe("parseMakingCode", () => {
+    const initials = (0, lens_1.stateCodeInitials)('FState');
+    it("should make code", () => {
+        expect((0, lens_1.parsePath)('/a/v0', (0, lens_1.stateCodeBuilder)(initials, 'opts'))).toEqual("state.copyWithIdentity().focusQuery('a').focusQuery('v0')");
+        expect((0, lens_1.parsePath)('~/a/$last', (0, lens_1.stateCodeBuilder)(initials, 'opts'))).toEqual("fullState.focusQuery('a').chain(Lenses.last())");
+        expect((0, lens_1.parsePath)('a/$append', (0, lens_1.stateCodeBuilder)(initials, 'opts'))).toEqual("state.focusQuery('a').chain(Lenses.append())");
+        expect((0, lens_1.parsePath)('a/[1]', (0, lens_1.stateCodeBuilder)(initials, 'opts'))).toEqual("state.focusQuery('a').chain(Lenses.nth(1))");
+        expect((0, lens_1.parsePath)('/a/[/a/b]', (0, lens_1.stateCodeBuilder)(initials, 'opts'))).toEqual("state.copyWithIdentity().focusQuery('a').chainNthFromPath(state.copyWithIdentity().focusQuery('a').focusQuery('b'))");
+        expect((0, lens_1.parsePath)('/a/[b]', (0, lens_1.stateCodeBuilder)(initials, 'opts'))).toEqual("state.copyWithIdentity().focusQuery('a').chainNthFromPath(state.focusQuery('b'))");
+    });
+});

package/dist/src/memoisation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/memoisation.spec.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@focuson/utils");
+describe("memoisation", () => {
+    it("should return the value if already in and generate it if it isn't in", () => {
+        expect((0, utils_1.memoise)("type1", "key1")(() => 'one_one')).toEqual("one_one");
+        expect((0, utils_1.memoise)("type1", "key2")(() => 'one_two')).toEqual("one_two");
+        expect((0, utils_1.memoise)("type1", "key1")(() => { throw new Error(); })).toEqual("one_one");
+        expect((0, utils_1.memoise)("type1", "key2")(() => { throw new Error(); })).toEqual("one_two");
+    });
+});

package/dist/src/messages.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/messages.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pages_1 = require("@focuson/pages");
+const rest_1 = require("@focuson/rest");
+const msg0 = { "level": "info", "msg": "the info message", "time": "2022-09-19T16:55:41.018Z" };
+const msg1 = { "level": "error", "msg": "the error message {/CommonIds/accountId}", "time": "2022-09-19T16:54:41.018Z" };
+const msg2 = { "level": "warning", "msg": "the warning message", "time": "2022-09-19T16:53:41.018Z" };
+const msg3 = { "level": "info", "msg": "loading the authorised charges", "time": "2022-09-19T16:52:41.018Z" };
+const dateFn = () => '2022-09-19T16:55:41.018Z';
+function addToState(...messages) {
+    return ({ messages });
+}
+const someMessages = addToState(msg0, msg1, msg2, msg3);
+describe("", () => {
+    it("Should not remove anything if the delayBeforeMessagesRemoved are undefined", () => {
+        expect((0, pages_1.removeOldMessages)(dateFn, (0, pages_1.simpleMessagesL)(), undefined)(someMessages)).toEqual(someMessages);
+    });
+    it("Should not remove messages older than the delayBeforeMessagesRemoved in milliseconds ", () => {
+        expect((0, pages_1.removeOldMessages)(dateFn, (0, pages_1.simpleMessagesL)(), 100)(someMessages)).toEqual(addToState(msg0));
+        expect((0, pages_1.removeOldMessages)(dateFn, (0, pages_1.simpleMessagesL)(), 60100)(someMessages)).toEqual(addToState(msg0, msg1));
+        expect((0, pages_1.removeOldMessages)(dateFn, (0, pages_1.simpleMessagesL)(), 120100)(someMessages)).toEqual(addToState(msg0, msg1, msg2));
+        expect((0, pages_1.removeOldMessages)(dateFn, (0, pages_1.simpleMessagesL)(), 180100)(someMessages)).toEqual(addToState(msg0, msg1, msg2, msg3));
+    });
+});
+describe("infoToSuccessMessagesPostProcessor", () => {
+    const processor = rest_1.infoToSuccessMessagesPostProcessor;
+    const msg1 = { msg: 'm1', level: 'info', time: 'someTime' };
+    const msg1AsSuccess = { msg: 'm1', level: 'success', time: 'someTime' };
+    const msg2 = { msg: 'm2', level: 'warning', time: 'someTime' };
+    const msg3 = { msg: 'm3', level: 'error', time: 'someTime' };
+    const msg4 = { msg: 'm4', level: 'success', time: 'someTime' };
+    expect(processor([])).toEqual([]);
+    expect(processor([msg1, msg2, msg3, msg4])).toEqual([msg1AsSuccess, msg2, msg3, msg4]);
+});

package/dist/src/modalButton.integration.spec.d.ts

@@ -0,0 +1,23 @@
+import { HasPageSelection } from "@focuson/pages";
+import { HasRestCommands } from "@focuson/rest";
+import { SimpleMessage } from "@focuson/utils";
+import { HasTagHolder } from "@focuson/template";
+interface ModalChildData {
+    data: string;
+}
+interface PageData {
+    child?: ModalChildData;
+    list?: ModalChildData[];
+    temp?: ModalChildData;
+    tempAr?: ModalChildData[];
+    index?: number;
+    nested?: {
+        child?: ModalChildData;
+        list?: ModalChildData[];
+    };
+}
+export interface ModalButtonStateForTest extends HasPageSelection, HasRestCommands, HasTagHolder {
+    messages: SimpleMessage[];
+    mainPage: PageData;
+}
+export {};

package/dist/src/modalButton.integration.spec.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const pages_1 = require("@focuson/pages");
+const rest_1 = require("@focuson/rest");
+const state_1 = require("@focuson/state");
+const enzyme_1 = require("enzyme");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+const utils_1 = require("@focuson/utils");
+const lens_1 = require("@focuson/lens");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+const emptyS = {
+    messages: [],
+    tags: {},
+    pageSelection: [{ "pageName": "mainPage", "pageMode": "view", time: 'now' }],
+    restCommands: [],
+    mainPage: {}
+};
+const emptyNestedS = Object.assign(Object.assign({}, emptyS), { mainPage: { nested: {} } });
+const dataS = Object.assign(Object.assign({}, emptyS), { mainPage: { child: { data: 'a' } } });
+const nestedS = Object.assign(Object.assign({}, emptyS), { mainPage: { nested: { child: { data: 'a' } } } });
+const listS = Object.assign(Object.assign({}, emptyS), { mainPage: {
+        index: 1,
+        list: [{ data: '0' }, { data: '1' }, { data: '2' }]
+    } });
+const pageDetails = { mainPage: { lens: (0, lens_1.identityOptics)().focusQuery('mainPage'), pageType: 'MainPage', pageFunction: () => (0, jsx_runtime_1.jsx)("span", {}), config: {}, pageMode: 'edit' } };
+const context = {
+    restL: (0, rest_1.restL)(),
+    combine: (state, pages) => (0, jsx_runtime_1.jsx)("div", { children: pages.map(p => p.element) }),
+    pageSelectionL: (0, pages_1.pageSelectionlens)(),
+    simpleMessagesL: (0, pages_1.simpleMessagesL)(),
+    pathToLens: (0, pages_1.fromPathFromRaw)((0, pages_1.pageSelectionlens)(), pageDetails),
+    pages: pageDetails,
+    commonIds: {},
+    newFetchers: {},
+    dateFn: utils_1.testDateFn,
+    restDetails: {},
+    closeOnePageTxs: pages_1.rawCloseOnePageTxs,
+    tagHolderL: lens_1.Lenses.identity().focusQuery('tags'),
+    currentState(state) { return state; },
+    messagePostProcessor: {},
+    mockJwt: true
+};
+function displayAndGetButton(s, setMain, fn) {
+    const comp = (0, enzyme_1.shallow)(fn((0, state_1.lensState)(s, setMain, 'ModalButton', context).focusOn('mainPage')));
+    return comp.find("button");
+}
+describe("modal buttons", () => {
+    describe("with single child", () => {
+        it("should copy", () => {
+            var remembered = {};
+            const button = displayAndGetButton(dataS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copy: [{ from: '~/child' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+            button.simulate('click');
+            expect(remembered).toEqual({
+                messages: [],
+                "tags": {},
+                mainPage: {
+                    "child": { "data": "a" },
+                    "temp": { "data": "a" }
+                },
+                "restCommands": [],
+                "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, { "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal", "time": "timeForTest", }],
+            });
+        });
+        it("should create empty", () => {
+            var remembered = {};
+            const button = displayAndGetButton(emptyS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, createEmpty: { data: 'data' }, focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+            button.simulate('click');
+            expect(remembered).toEqual({
+                messages: [],
+                "tags": {},
+                "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, { "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal", "time": "timeForTest", }],
+                "restCommands": [],
+                mainPage: { "temp": { "data": "data" } }
+            });
+        });
+        it("should copyJustString", () => {
+            var remembered = {};
+            const state = Object.assign(Object.assign({}, emptyS), { a: { x: 'somedata', y: 'other' } });
+            const button = displayAndGetButton(state, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copyJustString: [{ from: '/a', to: '/b', joiner: '*' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+            button.simulate('click');
+            expect(remembered).toEqual(Object.assign(Object.assign({}, state), { "b": "somedata*other", "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, { "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal", "time": "timeForTest", }] }));
+        });
+        it("should handle copyJustString when target is not there", () => {
+            var remembered = {};
+            const button = displayAndGetButton(emptyS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copyJustString: [{ from: '/a', to: '/b', joiner: '*' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+            button.simulate('click');
+            expect(remembered).toEqual(Object.assign(Object.assign({}, emptyS), { "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, { "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal", "time": "timeForTest", }] }));
+        });
+        it("should create empty, then copy back", () => {
+            var remembered = {};
+            displayAndGetButton(emptyS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, focusOn: '~/temp', createEmpty: { data: 'data' }, modal: 'someModal', copyOnClose: [{ to: '~/data' }], pageMode: 'view', dateFn: utils_1.testDateFn }))
+                .simulate('click');
+            expect(remembered).toEqual({
+                messages: [],
+                "tags": {},
+                "pageSelection": [
+                    { "pageName": "mainPage", "pageMode": "view", "time": "now", },
+                    {
+                        "focusOn": '~/temp', "firstTime": true, "pageMode": "view", "pageName": "someModal",
+                        copyOnClose: [{ to: "~/data" }], "time": "timeForTest",
+                    }
+                ],
+                "restCommands": [],
+                mainPage: { "temp": { "data": "data" } }
+            });
+            var remembered1 = {};
+            displayAndGetButton(remembered, s => remembered1 = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { id: 'id', state: state })).simulate('click');
+            console.log(JSON.stringify(remembered1, null, 2));
+            expect(remembered1).toEqual({
+                messages: [],
+                "tags": {},
+                "mainPage": { "temp": { "data": "data" }, "data": { "data": "data" } },
+                "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now", }],
+                "restCommands": []
+            });
+        });
+        it("should create empty, then copy back with a rest command", () => {
+            var remembered = {};
+            displayAndGetButton(emptyS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, focusOn: '~/temp', createEmpty: { data: 'data' }, rest: { name: 'restName', restAction: 'update' }, modal: 'someModal', copyOnClose: [{ to: '~/data' }], pageMode: 'view', dateFn: utils_1.testDateFn }))
+                .simulate('click');
+            expect(remembered).toEqual({
+                "mainPage": { "temp": { "data": "data" } },
+                "messages": [],
+                "tags": {},
+                "pageSelection": [
+                    { "pageMode": "view", "pageName": "mainPage", "time": "now", },
+                    {
+                        "copyOnClose": [{ "to": "~/data" }],
+                        "firstTime": true, "focusOn": "~/temp", "pageMode": "view", "pageName": "someModal",
+                        "rest": { "name": "restName", "restAction": "update" }, "time": "timeForTest",
+                    }
+                ],
+                "restCommands": []
+            });
+            var remembered1 = {};
+            displayAndGetButton(remembered, s => remembered1 = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { id: 'id', state: state })).simulate('click');
+            expect(remembered1).toEqual({
+                messages: [],
+                "tags": {},
+                "mainPage": { "temp": { "data": "data" }, "data": { "data": "data" } },
+                "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now", }],
+                "restCommands": [{ "name": "restName", "restAction": "update" }]
+            });
+        });
+    });
+});
+describe("with nested child", () => {
+    it("should copy", () => {
+        var remembered = {};
+        const button = displayAndGetButton(nestedS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copy: [{ from: '~/nested/child' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+        button.simulate('click');
+        expect(remembered).toEqual({
+            messages: [],
+            "tags": {},
+            mainPage: {
+                nested: { "child": { "data": "a" } },
+                "temp": { "data": "a" }
+            },
+            "restCommands": [],
+            "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, { "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal", "time": "timeForTest", }],
+        });
+    });
+    it("should create empty, then copy back", () => {
+        var remembered = {};
+        displayAndGetButton(emptyNestedS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, focusOn: '~/temp', createEmpty: { data: 'data' }, modal: 'someModal', copyOnClose: [{ to: '~/nested/data' }], pageMode: 'view', dateFn: utils_1.testDateFn }))
+            .simulate('click');
+        expect(remembered).toEqual({
+            messages: [],
+            "tags": {},
+            "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, {
+                    "firstTime": true, "pageMode": "view", "pageName": "someModal",
+                    "focusOn": "~/temp",
+                    copyOnClose: [{ "to": "~/nested/data" }],
+                    "time": "timeForTest",
+                }],
+            "restCommands": [],
+            mainPage: { "temp": { "data": "data" }, nested: {} }
+        });
+        var remembered1 = {};
+        displayAndGetButton(remembered, s => remembered1 = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { id: 'id', state: state })).simulate('click');
+        expect(remembered1).toEqual({
+            messages: [],
+            "tags": {},
+            "mainPage": { "temp": { "data": "data" }, nested: { "data": { "data": "data" } } },
+            "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now" }],
+            "restCommands": []
+        });
+    });
+    it("should create empty, then copy back with a rest command", () => {
+        var remembered = {};
+        displayAndGetButton(emptyNestedS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, focusOn: '~/temp', createEmpty: { data: 'data' }, rest: { name: 'restName', restAction: 'update' }, modal: 'someModal', copyOnClose: [{ to: '~/nested/data' }], pageMode: 'view', dateFn: utils_1.testDateFn }))
+            .simulate('click');
+        expect(remembered).toEqual({
+            messages: [],
+            "tags": {},
+            "pageSelection": [
+                { "pageName": "mainPage", "pageMode": "view", time: 'now' },
+                {
+                    "focusOn": "~/temp", rest: { name: 'restName', restAction: 'update' }, "firstTime": true, "pageMode": "view", "pageName": "someModal",
+                    copyOnClose: [{ "to": "~/nested/data" }], time: 'timeForTest'
+                }
+            ],
+            "restCommands": [],
+            mainPage: { "temp": { "data": "data" }, nested: {} }
+        });
+        var remembered1 = {};
+        displayAndGetButton(remembered, s => remembered1 = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { id: 'id', state: state })).simulate('click');
+        expect(remembered1).toEqual({
+            messages: [],
+            "tags": {},
+            "mainPage": { "temp": { "data": "data" }, nested: { "data": { "data": "data" } } },
+            "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now", }],
+            "restCommands": [{ "name": "restName", "restAction": "update" }]
+        });
+    });
+});
+describe("with lists of data", () => {
+    it("should copy from [1]", () => {
+        var remembered = {};
+        const button = displayAndGetButton(listS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copy: [{ from: '~/list[1]' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+        button.simulate('click');
+        expect(remembered).toEqual({
+            messages: [],
+            "tags": {},
+            mainPage: {
+                "index": 1,
+                list: [{ data: '0' }, { data: '1' }, { data: '2' }],
+                temp: { "data": "1" }
+            },
+            "restCommands": [],
+            "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now", }, { "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal", "time": "timeForTest", }],
+        });
+    });
+    it("should copy from [last]", () => {
+        var remembered = {};
+        const button = displayAndGetButton(listS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copy: [{ from: '~/list[$last]' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+        button.simulate('click');
+        expect(remembered.mainPage.temp).toEqual({ data: '2' });
+    });
+    it("should copy from [~/index]", () => {
+        var remembered = {};
+        const button = displayAndGetButton(listS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, copy: [{ from: '~/list/[~/index]' }], focusOn: '~/temp', modal: 'someModal', pageMode: 'view', dateFn: utils_1.testDateFn }));
+        button.simulate('click');
+        expect(remembered.mainPage.temp).toEqual({ data: '1' });
+    });
+});
+it("should create empty, then copy back", () => {
+    var remembered = {};
+    displayAndGetButton(emptyNestedS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, focusOn: '~/temp', createEmpty: { data: 'data' }, modal: 'someModal', copyOnClose: [{ to: '~/nested/data' }], pageMode: 'view', dateFn: utils_1.testDateFn }))
+        .simulate('click');
+    expect(remembered).toEqual({
+        messages: [],
+        "tags": {},
+        "pageSelection": [{ "pageName": "mainPage", "pageMode": "view", "time": "now" },
+            {
+                "focusOn": "~/temp", "firstTime": true, "pageMode": "view", "pageName": "someModal",
+                copyOnClose: [{ "to": "~/nested/data" }], "time": "timeForTest",
+            }],
+        "restCommands": [],
+        mainPage: { "temp": { "data": "data" }, nested: {} }
+    });
+    var remembered1 = {};
+    displayAndGetButton(remembered, s => remembered1 = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { id: 'id', state: state })).simulate('click');
+    expect(remembered1).toEqual({
+        messages: [],
+        "tags": {},
+        "mainPage": { "temp": { "data": "data" }, nested: { "data": { "data": "data" } } },
+        "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now" }],
+        "restCommands": []
+    });
+});
+it("should create empty, then copy back with a rest command", () => {
+    var remembered = {};
+    displayAndGetButton(emptyNestedS, s => remembered = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, focusOn: '~/temp', createEmpty: { data: 'data' }, rest: { name: 'restName', restAction: 'update' }, modal: 'someModal', copyOnClose: [{ to: '~/nested/data' }], pageMode: 'view', dateFn: utils_1.testDateFn }))
+        .simulate('click');
+    expect(remembered).toEqual({
+        messages: [],
+        "tags": {},
+        "pageSelection": [
+            { "pageName": "mainPage", "pageMode": "view", "time": "now", },
+            {
+                "focusOn": "~/temp", rest: { name: 'restName', restAction: 'update' }, "firstTime": true, "pageMode": "view", "pageName": "someModal",
+                copyOnClose: [{ "to": "~/nested/data" }], "time": "timeForTest",
+            }
+        ],
+        "restCommands": [],
+        mainPage: { "temp": { "data": "data" }, nested: {} }
+    });
+    var remembered1 = {};
+    displayAndGetButton(remembered, s => remembered1 = s, state => (0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { id: 'id', state: state })).simulate('click');
+    expect(remembered1).toEqual({
+        messages: [],
+        "tags": {},
+        "mainPage": { "temp": { "data": "data" }, nested: { "data": { "data": "data" } } },
+        "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now" }],
+        "restCommands": [{ "name": "restName", "restAction": "update", }]
+    });
+});

package/dist/src/modalButton.spec.d.ts

@@ -0,0 +1 @@
+export {};