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

package/dist/src/modalButton.spec.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const state_1 = require("@focuson/state");
+const enzyme_1 = require("enzyme");
+const pages_1 = require("@focuson/pages");
+const lens_1 = require("@focuson/lens");
+const utils_1 = require("@focuson/utils");
+const rest_1 = require("@focuson/rest");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+const context = {
+    simpleMessagesL: (0, pages_1.simpleMessagesL)(),
+    combine: (state, pages) => (0, jsx_runtime_1.jsx)("div", { children: pages.map(c => c.element) }),
+    pageSelectionL: (0, pages_1.pageSelectionlens)(),
+    pages: {
+        a: { lens: lens_1.Lenses.identity().focusQuery('a'), pageFunction: () => (0, jsx_runtime_1.jsx)("span", {}), config: {}, pageType: 'MainPage', pageMode: "edit" },
+        b: { lens: lens_1.Lenses.identity().focusQuery('b'), pageFunction: () => (0, jsx_runtime_1.jsx)("span", {}), config: {}, pageType: 'MainPage', pageMode: "edit" },
+    },
+    restL: (0, rest_1.restL)(),
+    dateFn: utils_1.testDateFn,
+    closeOnePageTxs: pages_1.rawCloseOnePageTxs,
+    tagHolderL: lens_1.Lenses.identity().focusQuery('tags'),
+    pathToLens: function (s, currentLens) {
+        throw new Error("Function not implemented.");
+    }
+};
+let startState = { pageSelection: [{ pageName: 'a', pageMode: 'view', time: 'now' }], messages: [], restCommands: [] };
+describe("modal button", () => {
+    it("should render with an id and title", () => {
+        const state = (0, state_1.lensState)(startState, (s) => { }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, modal: 'someModal', focusOn: '', pageMode: 'view', dateFn: utils_1.testDateFn }));
+        const button = comp.find("button");
+        expect(button.text()).toEqual('someTitle');
+    });
+    it("should change the state to have a model when clicked", () => {
+        var remembered = {};
+        const state = (0, state_1.lensState)(startState, (s) => { remembered = s; }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, modal: 'someModal', focusOn: '~/', pageMode: 'edit', dateFn: utils_1.testDateFn }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({
+            messages: [], "pageSelection": [
+                { "pageMode": "view", "pageName": "a", "time": "now" },
+                { "firstTime": true, "focusOn": "~/", "pageMode": "edit", "pageName": "someModal", "time": "timeForTest" }
+            ],
+            "restCommands": []
+        });
+    });
+    it("should create an empty if needed when clicked", () => {
+        var remembered = {};
+        const state = (0, state_1.lensState)(startState, (s) => { remembered = s; }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state.focusOn('data'), modal: 'someModal', focusOn: '~/', pageMode: 'edit', createEmpty: 'someData', dateFn: utils_1.testDateFn }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "a": "someData",
+            messages: [],
+            "pageSelection": [
+                { "pageMode": "view", "pageName": "a", "time": "now" },
+                { "firstTime": true, "focusOn": "~/", "pageMode": "edit", "pageName": "someModal", "time": "timeForTest" }
+            ],
+            "restCommands": []
+        });
+    });
+    it("should delete on open", () => {
+        var remembered = {};
+        const state = (0, state_1.lensState)(startState, (s) => { remembered = s; }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state.focusOn('data'), modal: 'someModal', focusOn: '~/', pageMode: 'edit', deleteOnOpen: ['~'], dateFn: utils_1.testDateFn }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({
+            messages: [],
+            "pageSelection": [
+                { "pageMode": "view", "pageName": "a", "time": "now" },
+                { "firstTime": true, "focusOn": "~/", "pageMode": "edit", "pageName": "someModal", "time": "timeForTest" }
+            ],
+            "restCommands": []
+        });
+    });
+});
+describe("modal button adding a main page", () => {
+    it("should change the state to have a main when clicked", () => {
+        var remembered = {};
+        const state = (0, state_1.lensState)(startState, (s) => { remembered = s; }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, main: 'b', pageMode: 'edit', dateFn: utils_1.testDateFn }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "restCommands": [], messages: [],
+            "pageSelection": [
+                { "pageMode": "view", "pageName": "a", "time": "now" },
+                { "firstTime": true, "pageMode": "edit", "pageName": "b", "time": "timeForTest" }
+            ]
+        });
+    });
+    it("should support copy in with paths  using the original page for copy from and the new page for copy to", () => {
+        var remembered = {};
+        const state = (0, state_1.lensState)(Object.assign(Object.assign({}, startState), { a: 123 }), (s) => { remembered = s; }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, main: 'b', pageMode: 'edit', dateFn: utils_1.testDateFn, copy: [{ from: '~', to: '~' }], copyOnClose: [{ from: '~' }] }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "a": 123,
+            "b": 123, // copied from page a
+            "restCommands": [], messages: [],
+            "pageSelection": [
+                { "pageMode": "view", "pageName": "a", "time": "now" },
+                { "firstTime": true, "pageMode": "edit", "pageName": "b", "time": "timeForTest", "copyOnClose": [{ "from": "~" }] }
+            ]
+        });
+    });
+    it("should support copy on close with defaults using the new page for copy from and the original page for copy to", () => {
+        var remembered = {};
+        const start = {
+            "a": undefined,
+            "b": 123,
+            "restCommands": [], messages: [],
+            "pageSelection": [
+                { "pageMode": "view", "pageName": "a", "time": "now" },
+                { "firstTime": true, "pageMode": "edit", "pageName": "b", "time": "timeForTest", "copyOnClose": [{ "from": "~", to: '~' }] }
+            ]
+        };
+        const state = (0, state_1.lensState)(start, (s) => { remembered = s; }, 'ModalButton', context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalCommitButton, { text: 'someTitle', id: 'someId', state: state }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "a": 123,
+            "b": 123,
+            "messages": [],
+            "pageSelection": [{ "pageMode": "view", "pageName": "a", "time": "now" }],
+            "restCommands": []
+        });
+    });
+});
+describe("restOnOpen", () => {
+    it("should create restCommands when clicked", () => {
+        var remembered = {};
+        const state = (0, state_1.lensState)(startState, (s) => { remembered = s; }, 'ModalButton', context);
+        const restOnOpen = { name: 'someRestName', restAction: 'get' };
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.ModalButton, { text: 'someTitle', id: 'someId', state: state, main: 'b', pageMode: 'edit', restOnOpen: restOnOpen, dateFn: utils_1.testDateFn }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered.restCommands).toEqual([restOnOpen]);
+    });
+});

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

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

package/dist/src/newFetchers.spec.js

@@ -0,0 +1,214 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const rest_1 = require("@focuson/rest");
+const utils_1 = require("@focuson/utils");
+const focuson_1 = require("@focuson/focuson");
+const lens_1 = require("@focuson/lens");
+const pages_1 = require("@focuson/pages");
+const messages_1 = require("@focuson/rest/src/messages");
+const empty = {
+    pageSelection: [{ pageName: 'pageName', pageMode: 'view', time: 'now' }],
+    tags: {},
+    restCommands: [],
+    messages: [],
+    debug: { restDebug: false, tagFetcherDebug: false }
+};
+const pageIdL = lens_1.Lenses.identity();
+const dataidL = lens_1.Lenses.identity();
+const fdd = {};
+const cd = {
+    id1: pageIdL.focusQuery('ids').focusQuery('id1'),
+    id2: pageIdL.focusQuery('ids').focusQuery('id2'),
+};
+const newFetchers = {
+    pageName: [{ tagName: 'someTag', restName: 'someRestName', postFetchCommands: [], on404Commands: [], onErrorCommands: [], onCompleteCommands: [] }]
+};
+function MyLoading() {
+    return (0, jsx_runtime_1.jsx)("p", { children: "Loading" });
+}
+const pages = {
+    // @ts-ignore
+    pageName: { pageType: "MainPage", pageMode: 'view', lens: pageIdL.focusQuery('data'), namedOptionals: {}, config: (0, pages_1.simpleMessagesPageConfig)(MyLoading) }
+};
+const oneRestDetails = {
+    extractData(status, body) { return body; },
+    fdLens: pageIdL.focusQuery('data'),
+    //From PostCodeMainPage.rest[address].targetFromPath (~/main). Does the path exist? Is the 'type' at the end of the path, the type that rest is fetching?
+    dLens: dataidL.focusQuery('a'),
+    cd,
+    fdd,
+    ids: ['id1', 'id2'],
+    jwtIds: ['id2'],
+    resourceId: [],
+    messages: (status, body) => status === undefined ?
+        [(0, utils_1.createSimpleMessage)('error', `Cannot connect. ${JSON.stringify(body)}`, (0, utils_1.testDateFn)())] :
+        [(0, utils_1.createSimpleMessage)('info', `${status}/${JSON.stringify(body)}`, (0, utils_1.testDateFn)())],
+    url: "/api/address?{query}",
+    states: {},
+    messagePostProcessors: (0, messages_1.justInfoToSuccessMessagesPostProcessor)(),
+    postProcessors: ['infoToSuccess']
+};
+const restDetails = {
+    someRestName: oneRestDetails
+};
+function fetchFn(a, b) {
+    return Promise.resolve([200, 123]);
+}
+function config(mockJwt) {
+    return {
+        fetchFn: fetchFn,
+        messageL: (0, pages_1.simpleMessagesL)(),
+        newFetchers: newFetchers,
+        onError(s, e) { throw Error(`on error. ${e}\n${JSON.stringify(s)}`); },
+        pageL: pageIdL.focusOn('pageSelection'),
+        pages,
+        postMutate(s) { return Promise.resolve(s); },
+        preMutate(s) { return s; },
+        restDetails,
+        restL: (0, rest_1.restL)(),
+        restUrlMutator(r, url) { return url; },
+        stringToMsg: (0, utils_1.stringToSimpleMsg)(utils_1.testDateFn, 'info'),
+        tagHolderL: pageIdL.focusQuery('tags'),
+        maxRestCount: 5,
+        restCountL: (0, focuson_1.restCountL)()
+    };
+}
+const someConfig = config(true);
+const pathToLens = (s) => (path) => {
+    throw new Error(`called path to lens with ${path}`);
+};
+describe("test setup for new fetcher", () => {
+    it("just check the rest works ", () => __awaiter(void 0, void 0, void 0, function* () {
+        const pageL = (0, lens_1.identityOptics)().focusQuery('pageSelection');
+        const props = {
+            fetchFn, mockJwt: true, d: restDetails, urlMutatorForRest: someConfig.restUrlMutator, pathToLens, messageL: someConfig.messageL,
+            // @ts-ignore
+            pageL,
+            traceL: (0, focuson_1.traceL)(), stringToMsg: someConfig.stringToMsg
+        };
+        const [actual] = yield (0, rest_1.restToTransforms)(props, () => empty, {}, [{ name: 'someRestName', restAction: 'get' }]);
+        expect(actual.restCommand).toEqual({ name: 'someRestName', restAction: 'get' });
+        expect(actual.status).toEqual(200);
+        const txs = actual.txs.map(([l, tx]) => [l.description, tx(l.getOption(empty))]);
+        expect(txs).toEqual([
+            [
+                "I.focus?(messages)",
+                [
+                    {
+                        "level": "success",
+                        "msg": "200/123",
+                        "time": "timeForTest"
+                    }
+                ]
+            ],
+            [
+                "I.focus?(data).chain(I.focus?(a))",
+                123
+            ]
+        ]);
+    }));
+});
+describe("restCommandsFromFetchers should create a rest command when needed", () => {
+    it("empty - no tags - should not load", () => {
+        expect((0, focuson_1.restCommandsFromFetchers)(someConfig.tagHolderL, someConfig.newFetchers, someConfig.restDetails, 'pageName', empty)).toEqual([]);
+    });
+    it("populated but the tags undefined - should not load", () => {
+        expect((0, focuson_1.restCommandsFromFetchers)(someConfig.tagHolderL, someConfig.newFetchers, someConfig.restDetails, 'pageName', Object.assign(Object.assign({}, empty), { data: { a: 123 } }))).toEqual([]);
+    });
+    it("current tags defined and same - should not load", () => {
+        expect((0, focuson_1.restCommandsFromFetchers)(someConfig.tagHolderL, someConfig.newFetchers, someConfig.restDetails, 'pageName', Object.assign(Object.assign({}, empty), { tags: { pageName_someTag: ['111', '222'] }, ids: { id1: 111, id2: 222 }, data: { a: 123 } }))).toEqual([]);
+    });
+    it("current tags defined -tags different - should load", () => {
+        expect((0, focuson_1.restCommandsFromFetchers)(someConfig.tagHolderL, someConfig.newFetchers, someConfig.restDetails, 'pageName', Object.assign(Object.assign({}, empty), { tags: { pageName_someTag: ['111', '222'] }, ids: { id1: 111, id2: 333 }, data: { a: 123 } }))).toEqual([
+            {
+                "comment": "Fetcher",
+                "changeOnCompletion": [],
+                "changeOnSuccess": [],
+                "name": "someRestName",
+                on404: [],
+                onError: [],
+                "restAction": "get",
+                "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "333"] }
+            }
+        ]);
+    });
+    it("not populated tags defined and same - should load", () => {
+        expect((0, focuson_1.restCommandsFromFetchers)(someConfig.tagHolderL, someConfig.newFetchers, someConfig.restDetails, 'pageName', Object.assign(Object.assign({}, empty), { tags: { pageName_someTag: ['111', '222'] }, ids: { id1: 111, id2: 222 } }))).toEqual([
+            { "comment": "Fetcher", "changeOnSuccess": [], "changeOnCompletion": [], "name": "someRestName", on404: [], onError: [], "restAction": "get", "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "222"] } }
+        ]);
+    });
+    it(" populated tags not defined  - should load", () => {
+        expect((0, focuson_1.restCommandsFromFetchers)(someConfig.tagHolderL, someConfig.newFetchers, someConfig.restDetails, 'pageName', Object.assign(Object.assign({}, empty), { ids: { id1: 111, id2: 222 }, data: { a: 123 } }))).toEqual([
+            { "comment": "Fetcher", "changeOnCompletion": [], "changeOnSuccess": [], "name": "someRestName", on404: [], onError: [], "restAction": "get", "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "222"] } }
+        ]);
+    });
+});
+describe("processRestsAndFetchers", () => {
+    it("should load if fetcher needs it - mockJwt true", () => __awaiter(void 0, void 0, void 0, function* () {
+        const [actual] = yield (0, focuson_1.processRestsAndFetchers)(config(true), (0, focuson_1.defaultPageSelectionAndRestCommandsContext)(pages, {}, newFetchers, restDetails, utils_1.testDateFn, true))([])(() => (Object.assign(Object.assign({}, empty), { ids: { id1: 111, id2: 222 } })));
+        expect(actual.restCommand).toEqual({
+            name: 'someRestName', on404: [], onError: [], restAction: 'get', comment: 'Fetcher', "changeOnSuccess": [], "changeOnCompletion": [],
+            "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "222"] }
+        });
+        expect(actual.status).toEqual(200);
+        const txs = actual.txs.map(([l, tx]) => [l.description, tx(l.getOption(empty))]);
+        expect(txs).toEqual([
+            ["I.focus?(messages)",
+                [{ "level": "success", "msg": "200/123", "time": "timeForTest" }]],
+            ["I.focus?(data).chain(I.focus?(a))", 123],
+            ["I.focus?(tags).focusOn(pageName_someTag)", ["111", "222"]]
+        ]);
+    }));
+    it("should load if fetcher needs it - mockJwt false", () => __awaiter(void 0, void 0, void 0, function* () {
+        const [actual] = yield (0, focuson_1.processRestsAndFetchers)(config(true), (0, focuson_1.defaultPageSelectionAndRestCommandsContext)(pages, {}, newFetchers, restDetails, utils_1.testDateFn, false))([])(() => (Object.assign(Object.assign({}, empty), { ids: { id1: 111, id2: 222 } })));
+        expect(actual.restCommand).toEqual({
+            name: 'someRestName', on404: [], onError: [], restAction: 'get', comment: 'Fetcher', "changeOnSuccess": [], "changeOnCompletion": [],
+            "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "222"] }
+        });
+        expect(actual.status).toEqual(200);
+        const txs = actual.txs.map(([l, tx]) => [l.description, tx(l.getOption(empty))]);
+        expect(txs).toEqual([
+            ["I.focus?(messages)",
+                [{ "level": "success", "msg": "200/123", "time": "timeForTest" }]],
+            ["I.focus?(data).chain(I.focus?(a))", 123],
+            ["I.focus?(tags).focusOn(pageName_someTag)", ["111", "222"]]
+        ]);
+    }));
+    it("should load and record trace if fetcher needs it and recordTrace is on", () => __awaiter(void 0, void 0, void 0, function* () {
+        const [actual] = yield (0, focuson_1.processRestsAndFetchers)(config(true), (0, focuson_1.defaultPageSelectionAndRestCommandsContext)(pages, {}, newFetchers, restDetails, utils_1.testDateFn, true))([])(() => (Object.assign(Object.assign({}, empty), { ids: { id1: 111, id2: 222 }, debug: { recordTrace: true } })));
+        expect(actual.restCommand).toEqual({
+            name: 'someRestName', on404: [], onError: [], restAction: 'get', comment: 'Fetcher', "changeOnSuccess": [], "changeOnCompletion": [],
+            "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "222"] }
+        });
+        expect(actual.status).toEqual(200);
+        const txs = actual.txs.map(([l, tx]) => [l.description, tx(l.getOption(empty))]);
+        expect(txs).toEqual([
+            ["I.focus?(messages)", [{ "level": "success", "msg": "200/123", "time": "timeForTest" }]],
+            ["I.focus?(data).chain(I.focus?(a))", 123],
+            ["I.focus?(trace)",
+                [{
+                        "lensTxs": [
+                            ["I.focus?(messages)", [{ "level": "success", "msg": "200/123", "time": "timeForTest" }]],
+                            ["I.focus?(data).chain(I.focus?(a))", 123],
+                        ],
+                        "restCommand": { "comment": "Fetcher", "changeOnCompletion": [], "changeOnSuccess": [], "name": "someRestName", on404: [], onError: [], "restAction": "get", "tagNameAndTags": { "tagName": "pageName_someTag", "tags": ["111", "222"] } }
+                    }]
+            ],
+            ["I.focus?(tags).focusOn(pageName_someTag)", ["111", "222"]]
+        ]);
+    }));
+    it("should not load if fetcher doesn't needs it", () => __awaiter(void 0, void 0, void 0, function* () {
+        const actual = yield (0, focuson_1.processRestsAndFetchers)(config(true), (0, focuson_1.defaultPageSelectionAndRestCommandsContext)(pages, {}, newFetchers, restDetails, utils_1.testDateFn, true))([])(() => empty);
+        expect(actual).toEqual([]);
+    }));
+});

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

@@ -0,0 +1,2 @@
+import { State } from "./fetcher.fixture";
+export declare let state: State;

package/dist/src/optics.spec.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.state = void 0;
+const lens_1 = require("@focuson/lens");
+exports.state = {};
+let ab = { a: "a", b: "b" };
+let holder = { ab, c: "c" };
+describe("identityOptics ", () => {
+    it("should implement 'identity' for the four methods", () => {
+        expect((0, lens_1.identityOptics)().set(1, 2)).toBe(2);
+        expect((0, lens_1.identityOptics)().get(1)).toBe(1);
+        expect((0, lens_1.identityOptics)().getOption(1)).toBe(1);
+        expect((0, lens_1.identityOptics)().reverseGet(1)).toBe(1);
+    });
+});
+describe("iso", () => {
+    let iso = new lens_1.Iso(i => [i.a, i.b], ab => ({
+        a: ab[0],
+        b: ab[1]
+    }), "desc");
+    it("should have a description", () => {
+        expect(iso.toString()).toEqual("Iso(desc)");
+        expect((0, lens_1.identityOptics)().toString()).toEqual("Iso(I)");
+        expect((0, lens_1.identityOptics)("desc").toString()).toEqual("Iso(desc)");
+    });
+    it("should flip between the two representations", () => {
+        expect(iso.get(ab)).toEqual(["a", "b"]);
+        expect(iso.getOption(ab)).toEqual(["a", "b"]);
+        expect(iso.set({ "a": "not", "b": "used" }, ["a", "b"])).toEqual(ab);
+        expect(iso.reverseGet(["a", "b"])).toEqual({ "a": "a", "b": "b" });
+    });
+    it("should have be focusable, and return a lens", () => {
+        let toA = (0, lens_1.identityOptics)().focusOn('a');
+        expect(toA.set(ab, "newA")).toEqual({ a: "newA", b: "b" });
+        expect(toA.get(ab)).toBe("a");
+        expect(toA.getOption(ab)).toEqual("a");
+        expect(toA.toString()).toEqual("Lens(I.focusOn(a))");
+    });
+    it("should have be focusQuery and return an optional", () => {
+        let toA = (0, lens_1.identityOptics)().focusQuery('a');
+        expect(toA.set(ab, "newA")).toEqual({ a: "newA", b: "b" });
+        expect(toA.getOption(ab)).toEqual("a");
+        expect(toA.getOption({})).toEqual(undefined);
+        expect(toA.toString()).toEqual("Optional(I.focus?(a))");
+    });
+    it("should return a lens if chained with a lens", () => {
+        let toA = (0, lens_1.identityOptics)().chainLens((0, lens_1.identityOptics)().focusOn('a'));
+        expect(toA.set(ab, "newA")).toEqual({ a: "newA", b: "b" });
+        expect(toA.getOption(ab)).toEqual("a");
+        expect(toA.toString()).toEqual("Lens(I.chain(I.focusOn(a)))");
+    });
+});
+let lensToAWithDefault = (0, lens_1.identityOptics)().focusOn('ab').focusWithDefault('a', "defaultA");
+describe("lens", () => {
+    it("should be focusable and return a lens", () => {
+        let lensToa = (0, lens_1.identityOptics)().focusOn('ab').focusOn('a');
+        expect(lensToa.set(holder, "newA")).toEqual({ ab: { a: "newA", b: "b" }, c: "c" });
+        expect(lensToa.setOption(holder, "newA")).toEqual({ ab: { a: "newA", b: "b" }, c: "c" });
+        expect(lensToa.get(holder)).toEqual("a");
+        expect(lensToa.getOption(holder)).toEqual("a");
+        expect(lensToa.toString()).toEqual("Lens(I.focusOn(ab).focusOn(a))");
+    });
+    it("should allow chained lens", () => {
+        let lensToa = (0, lens_1.identityOptics)().chainLens((0, lens_1.identityOptics)().focusOn('ab')).chainLens((0, lens_1.identityOptics)().focusOn('a'));
+        expect(lensToa.set(holder, "newA")).toEqual({ ab: { a: "newA", b: "b" }, c: "c" });
+        expect(lensToa.setOption(holder, "newA")).toEqual({ ab: { a: "newA", b: "b" }, c: "c" });
+        expect(lensToa.get(holder)).toEqual("a");
+        expect(lensToa.getOption(holder)).toEqual("a");
+        expect(lensToa.toString()).toEqual("Lens(I.chain(I.focusOn(ab)).chain(I.focusOn(a)))");
+    });
+    it("should allow focusWithDefault creating a lens with a default value ", () => {
+        expect(lensToAWithDefault.get({ ab: {}, c: "c" })).toEqual("defaultA");
+        expect(lensToAWithDefault.getOption({ ab: {}, c: "c" })).toEqual("defaultA");
+        expect(lensToAWithDefault.set({ ab: {}, c: "c" }, "someA")).toEqual({ ab: { a: "someA" }, c: "c" });
+        expect(lensToAWithDefault.setOption({ ab: {}, c: "c" }, "someA")).toEqual({ ab: { a: "someA" }, c: "c" });
+        expect(lensToAWithDefault.toString()).toEqual("Lens(I.focusOn(ab).focusWithDefault(a))");
+    });
+    it("should have a focusQuery creating an optional", () => {
+        let optToQueryA = (0, lens_1.identityOptics)().focusOn('ab').focusQuery('a');
+        expect(optToQueryA.getOption({ ab: {}, c: "c" })).toEqual(undefined);
+        expect(optToQueryA.getOption({ ab: { a: "a" }, c: "c" })).toEqual("a");
+        expect(optToQueryA.set({ ab: {}, c: "c" }, "newA")).toEqual({ ab: { a: "newA" }, c: "c" });
+        expect(optToQueryA.set({ ab: { a: "a" }, c: "c" }, "newA")).toEqual({ ab: { a: "newA" }, c: "c" });
+        expect(optToQueryA.setOption({ ab: {}, c: "c" }, "newA")).toEqual({ ab: { a: "newA" }, c: "c" });
+        expect(optToQueryA.setOption({ ab: { a: "a" }, c: "c" }, "newA")).toEqual({ ab: { a: "newA" }, c: "c" });
+        expect(optToQueryA.toString()).toEqual("Optional(I.focusOn(ab).focus?(a))");
+    });
+    it("should have a focusQuery that keeps on nesting: depth 2, and the getOption returns undefined if nothing there", () => {
+        let optToQueryA = (0, lens_1.identityOptics)().focusOn('ab').focusQuery('ab').focusQuery('ab').focusQuery('a');
+        expect(optToQueryA.getOption({ ab: {}, c: "c" })).toEqual(undefined);
+        expect(optToQueryA.getOption({ ab: { ab: {} }, c: "c" })).toEqual(undefined);
+        expect(optToQueryA.getOption({ ab: { ab: { ab: {} } }, c: "c" })).toEqual(undefined);
+        expect(optToQueryA.getOption({ ab: { ab: { ab: { a: "a" } } }, c: "c" })).toEqual("a");
+        expect(optToQueryA.toString()).toEqual("Optional(I.focusOn(ab).focus?(ab).focus?(ab).focus?(a))");
+    });
+    it("should have a focusQuery that keeps on nesting: depth 2, and the setOption put it's there anyway", () => {
+        let lensToqueryA = (0, lens_1.identityOptics)().focusOn('ab').focusQuery('ab').focusQuery('ab').focusQuery('a');
+        expect(lensToqueryA.setOption({ ab: {}, c: "c" }, "a")).toEqual({
+            "ab": { "ab": { "ab": { "a": "a" } } },
+            "c": "c"
+        });
+        expect(lensToqueryA.setOption({ ab: { ab: {} }, c: "c" }, "a")).toEqual({
+            "ab": { "ab": { "ab": { "a": "a" } } },
+            "c": "c"
+        });
+        expect(lensToqueryA.setOption({ ab: { ab: { ab: {} } }, c: "c" }, "a")).toEqual({
+            "ab": { "ab": { "ab": { "a": "a" } } },
+            "c": "c"
+        });
+        expect(lensToqueryA.setOption({ ab: { ab: { ab: { a: "oldA" } } }, c: "c" }, "a")).toEqual({
+            ab: { ab: { ab: { a: "a" } } },
+            c: "c"
+        });
+        expect(lensToqueryA.toString()).toEqual("Optional(I.focusOn(ab).focus?(ab).focus?(ab).focus?(a))");
+    });
+    it("should have a focusQuery that keeps on nesting: depth 2, ", () => {
+        let lensToqueryA = (0, lens_1.identityOptics)().focusOn('ab').focusQuery('ab').focusQuery('ab').focusQuery('a');
+        expect(lensToqueryA.set({ ab: {}, c: "c" }, "a")).toEqual({ "ab": { "ab": { "ab": { "a": "a" } } }, "c": "c" });
+        expect(lensToqueryA.set({ ab: { ab: {} }, c: "c" }, "a")).toEqual({ "ab": { "ab": { "ab": { "a": "a" } } }, "c": "c" });
+        expect(lensToqueryA.set({ ab: { ab: { ab: {} } }, c: "c" }, "a")).toEqual({ ab: { ab: { ab: { a: "a" } } }, c: "c" });
+        expect(lensToqueryA.set({ ab: { ab: { ab: { a: "oldA" } } }, c: "c" }, "a")).toEqual({ ab: { ab: { ab: { a: "a" } } }, c: "c" });
+        expect(lensToqueryA.toString()).toEqual("Optional(I.focusOn(ab).focus?(ab).focus?(ab).focus?(a))");
+    });
+    it("should have a combineWith creating a lens focused on both", () => {
+        let abL = (0, lens_1.identityOptics)().focusOn('ab');
+        let aL = abL.focusOn('a');
+        let bL = abL.focusOn('b');
+        let aCombinedBL = aL.combineLens(bL);
+        expect(aCombinedBL.get(holder)).toEqual(["a", "b"]);
+        expect(aCombinedBL.getOption(holder)).toEqual(["a", "b"]);
+        expect(aCombinedBL.set(holder, ["newA", "newB"])).toEqual({ ab: { a: "newA", b: "newB" }, c: "c" });
+        expect(aCombinedBL.toString()).toEqual("Lens(combine(I.focusOn(ab).focusOn(a),I.focusOn(ab).focusOn(b)))");
+    });
+});
+describe("optional.setOption", () => {
+    const lensToB = lens_1.Lenses.identity().focusQuery("a").focusQuery('b').focusQuery('c');
+    const lensToTheTag = lens_1.Lenses.identity().focusQuery("tags").focusQuery('tag').focusQuery('thetag');
+    const targetAndTagL = lensToB.combine(lensToTheTag);
+    let expected = {
+        "a": { "b": { "c": "newTarget" } },
+        "tags": { "tag": { "thetag": "newTag" } }
+    };
+    it("should allow a nested focuses lens to create parents - depth 2", () => {
+        expect(lensToTheTag.setOption({}, 'newTarget')).toEqual({ "tags": { "tag": { "thetag": "newTarget" } } });
+    });
+    it("should allow a nested focuses lens to create parents - depth 3", () => {
+        expect(lensToB.setOption({}, 'newTag')).toEqual({ "a": { "b": { "c": "newTag" } } });
+    });
+    it("should allowed a combined 'tags' plus 'value' optional to work when neither parent is there", () => {
+        expect(targetAndTagL.setOption({}, ['newTarget', 'newTag'])).toEqual(expected);
+    });
+    it("should allowed a combined 'tags' plus 'value' optional to work when only tags parent present", () => {
+        expect(targetAndTagL.setOption({ tags: { tag: {} } }, ['newTarget', 'newTag'])).toEqual(expected);
+        expect(targetAndTagL.setOption({ tags: {} }, ['newTarget', 'newTag'])).toEqual(expected);
+    });
+    it("should allowed a combined 'tags' plus 'value' optional to work when only target parent present", () => {
+        expect(targetAndTagL.setOption({ a: { b: { c: '' } } }, ['newTarget', 'newTag'])).toEqual(expected);
+    });
+});
+const dataA = {
+    cond: 'a',
+    true: { a: 1 }
+};
+const dataB = {
+    cond: 'b',
+    false: { b: 2 }
+};
+describe("conditional lens", () => {
+    const id = lens_1.Lenses.identity();
+    const condL = id.focusOn('cond');
+    const trueL = id.focusQuery('true').focusOn('a');
+    const falseL = id.focusQuery('false').focusOn('b');
+    const lens = lens_1.Lenses.condition(condL, c => c === 'a', trueL, falseL);
+    it("should be able to get data", () => {
+        expect(lens.getOption(dataA)).toEqual(1);
+        expect(lens.getOption(dataB)).toEqual(2);
+    });
+    it("should be able to set data", () => {
+        expect(lens.setOption(dataA, 3)).toEqual({ "cond": "a", "true": { "a": 3 } });
+        expect(lens.setOption(dataB, 3)).toEqual({ "cond": "b", "false": { "b": 3 } });
+    });
+    it("should have a description", () => {
+        expect(lens.description).toEqual('If(I.focusOn(cond)) then I.focus?(true).focusOn(a) else I.focus?(false).focusOn(b)');
+    });
+});
+describe("calculatedNth", () => {
+    const id = lens_1.Lenses.identity();
+    const l = lens_1.Lenses.calculatedNth(id.focusQuery('n'), id.focusQuery('ts'));
+    it('should get the nth item', () => {
+        expect(l.getOption({ n: 1, ts: ['zero', 'one', 'two'] })).toEqual('one');
+    });
+    it('should set the nth item', () => {
+        expect(l.setOption({ n: 1, ts: ['zero', 'one', 'two'] }, 'x')).toEqual({ "n": 1, "ts": ["zero", "x", "two"] });
+    });
+});

package/dist/src/page.fixture.d.ts

@@ -0,0 +1,30 @@
+import { HasPageSelection, MultiPageDetails, PageConfig } from "@focuson/pages";
+import { HasSimpleMessages, PageMode, SimpleMessage } from "@focuson/utils";
+import { FocusOnContext } from "@focuson/focuson";
+import { HasTagHolder } from "@focuson/template";
+import { HasRestCommands, RestCommand } from "@focuson/rest";
+export interface PageSpecState extends HasPageSelection, HasSimpleMessages, HasTagHolder, HasRestCommands {
+    tag1?: string;
+    tag2?: string;
+    tempData?: string;
+    firstPage?: string;
+    secondPage?: SecondPageDomain;
+}
+export interface SecondPageDomain {
+    fromApi?: string;
+}
+export declare const emptyState: PageSpecState;
+export declare const rootState: PageSpecState;
+export declare const dataDefinedState: PageSpecState;
+export declare const firstPageSelectedState: PageSpecState;
+export declare const firstPageWithFirstTime: PageSpecState;
+export declare const secondPageSelectedState: PageSpecState;
+export declare const invalidPageState: PageSpecState;
+export declare function stateWith(main: PageSpecState, ...nameAndModes: [string, PageMode, RestCommand | undefined][]): PageSpecState;
+export declare function stateWithFirstTimes(main: PageSpecState, ...nameAndModes: [string, PageMode, RestCommand | undefined][]): PageSpecState;
+export declare function lensStateWith(main: PageSpecState, setMain: (s: PageSpecState) => void, ...nameAndModes: [string, PageMode, RestCommand | undefined][]): import("@focuson/state").LensState<PageSpecState, PageSpecState, ContextForTest>;
+export type ContextForTest = FocusOnContext<PageSpecState>;
+export declare function pageSpecStateConfig<D>(): PageConfig<PageSpecState, D, SimpleMessage[], ContextForTest>;
+export declare const pageDetails: MultiPageDetails<PageSpecState, ContextForTest>;
+export type PageDetails = typeof pageDetails;
+export declare const context: ContextForTest;