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

package/dist/src/fetchers.spec.js

@@ -0,0 +1,346 @@
+"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 fetcher_1 = require("@focuson/fetcher");
+const lens_1 = require("@focuson/lens");
+const shouldLoadTrue = (t) => [];
+const shouldLoadFalse = (t) => ['some reason'];
+const reqInit = { keepalive: true };
+const loadAddsDot = (s) => (0, fetcher_1.loadInfo)(`load url from ${s}`, reqInit, (state) => (status, json) => "." + state + "/" + status + "/" + json);
+let loadTrueF = (0, fetcher_1.fetcher)(shouldLoadTrue, loadAddsDot, "loadTrueF");
+let loadFalseF = (0, fetcher_1.fetcher)(shouldLoadFalse, loadAddsDot, "loadFalseF");
+let useInsteadOfLoad = (0, fetcher_1.loadDirectly)((s) => s + "loaded");
+let loadTrueAndUseInstead = (0, fetcher_1.fetcher)(shouldLoadTrue, s => useInsteadOfLoad, "");
+describe("fetcher", () => {
+    it("should make a fetcher", () => {
+        expect(loadTrueF).toEqual({ shouldLoad: shouldLoadTrue, load: loadAddsDot, "description": "loadTrueF" });
+    });
+});
+function myfetch(req, init) {
+    return Promise.resolve([200, "someString"]);
+}
+describe("apply fetcher", () => {
+    it("load when load returns true", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield (0, fetcher_1.applyFetcher)(loadTrueF, "original", myfetch)).toEqual(".original/200/someString");
+    }));
+    it("not load when load returns false", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield (0, fetcher_1.applyFetcher)(loadFalseF, "original", myfetch)).toEqual("original");
+    }));
+    it("uses this instead of load if defined", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield (0, fetcher_1.applyFetcher)(loadTrueAndUseInstead, "oldstate", myfetch)).toEqual("oldstateloaded");
+    }));
+});
+describe("lens fetcher ", () => {
+    const opticsTo = (0, lens_1.identityOptics)().focusQuery('ab').focusQuery('a');
+    let fTrue = (0, fetcher_1.lensFetcher)(opticsTo, loadTrueF);
+    let fFalse = (0, fetcher_1.lensFetcher)(opticsTo, loadFalseF, "fFalse");
+    it("should have a  description", () => {
+        expect(fTrue.description).toEqual("lensFetcher(Optional(I.focus?(ab).focus?(a)),loadTrueF)");
+        expect(fFalse.description).toEqual("fFalse");
+    });
+    it("when child condition is false", () => {
+        expect(fFalse.shouldLoad({})).toEqual(["emptyFocusedOnState"]);
+    });
+    it.skip("when child  condition is true BUT the place the child is going to be added to is undefined", () => {
+        expect(fTrue.shouldLoad({})).toEqual(false); //there is no ab to put the value loaded into
+        // const [req, reqInit, mutate] = fTrue.load({ab: {}})
+    });
+    it("when child  doesnt exist, even if the condition would be true", () => {
+        let state = { ab: {} };
+        expect(fTrue.shouldLoad(state)).toEqual(["emptyFocusedOnState"]);
+    });
+    it("when child  condition is true", () => {
+        let state = { ab: { a: 'something' } };
+        expect(fTrue.shouldLoad(state)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = fTrue.load({ ab: { a: '' } });
+        expect(mutate(state)(200, "someValue")).toEqual({ "ab": { "a": ".something/200/someValue" } });
+    });
+});
+describe("lens fetcher", () => {
+    it("when state defined but holder is undefined", () => {
+        const opticsTo = (0, lens_1.identityOptics)().focusQuery('ab').focusQuery('a');
+        let f = (0, fetcher_1.lensFetcher)(opticsTo, loadTrueF);
+        expect(f.shouldLoad({})).toEqual(["emptyFocusedOnState"]);
+    });
+    it("when state defined, holder is defined and condition is false", () => {
+        const opticsTo = (0, lens_1.identityOptics)().focusQuery('ab').focusQuery('a');
+        let f = (0, fetcher_1.lensFetcher)(opticsTo, loadFalseF);
+        expect(f.shouldLoad({ ab: {} })).toEqual(["emptyFocusedOnState"]);
+    });
+    it("when state defined, holder is defined child is undefined and coniditon is true", () => {
+        const opticsTo = (0, lens_1.identityOptics)().focusQuery('ab').focusQuery('a');
+        let f = (0, fetcher_1.lensFetcher)(opticsTo, loadTrueF);
+        let state = { ab: {} };
+        expect(f.shouldLoad(state)).toEqual(["emptyFocusedOnState"]);
+        // const {requestInfo, requestInit, mutate} = f.load(state)
+        // expect(requestInfo).toEqual("load url from undefined")
+        // expect(mutate(state)(200, "newValue")).toEqual({"ab": {"a": ".undefined/200/newValue"}})
+    });
+    it("when state defined, holder is defined child is defined and coniditon is true", () => {
+        const opticsTo = (0, lens_1.identityOptics)().focusQuery('ab').focusQuery('a');
+        let f = (0, fetcher_1.lensFetcher)(opticsTo, loadTrueF);
+        let state = { ab: { a: "a" } };
+        expect(f.shouldLoad(state)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = f.load(state);
+        expect(requestInfo).toEqual("load url from a");
+        expect(mutate(state)(200, "newValue")).toEqual({ "ab": { "a": ".a/200/newValue" } });
+    });
+});
+describe("fetcherWhenUndefined", () => {
+    let opticToA = (0, lens_1.identityOptics)().focusQuery('a');
+    const fOKToLoad = (0, fetcher_1.fetcherWhenUndefined)(opticToA, s => ["someUrl", reqInit]);
+    const fErrorIfLoad = (0, fetcher_1.fetcherWhenUndefined)(opticToA, () => {
+        throw Error('');
+    }, "fErrorIfLoad");
+    it("should have a description", () => {
+        expect(fOKToLoad.description).toEqual("fetcherWhenUndefined(Optional(I.focus?(a)))");
+        expect(fErrorIfLoad.description).toEqual("fErrorIfLoad");
+    });
+    it('doesnt loads when the focused on thing is defined', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(fOKToLoad.shouldLoad({ a: "someValue" })).toEqual(["defined"]);
+    }));
+    it('loads when the focused on thing is undefined', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(fOKToLoad.shouldLoad({})).toEqual([]);
+        const { requestInfo, requestInit, mutate } = fOKToLoad.load({});
+        expect(requestInfo).toEqual("someUrl");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate({})(200, "someString")).toEqual({
+            "a": "someString"
+        });
+    }));
+});
+let entityAndNameI = (0, lens_1.dirtyPrism)(en => [en.tags, en.entity], arr => ({
+    tags: arr[0],
+    entity: arr[1]
+}));
+describe("fetchAndMutate", () => {
+    const fMutateTrue = (0, fetcher_1.fetchAndMutate)(loadTrueF, s => s + "_mut");
+    const fMutateFalse = (0, fetcher_1.fetchAndMutate)(loadFalseF, s => s + "_mut", "someDesc");
+    it("should have a description", () => {
+        expect(fMutateTrue.description).toEqual("loadTrueF.withMutate");
+        expect(fMutateFalse.description).toEqual("someDesc");
+    });
+    it("shouldLoad if the original shouldLoad", () => {
+        expect(fMutateTrue.shouldLoad).toBe(loadTrueF.shouldLoad);
+        expect(fMutateFalse.shouldLoad).toBe(loadFalseF.shouldLoad);
+    });
+    it("should load and then mutate", () => {
+        const { requestInfo, requestInit, mutate } = fMutateTrue.load("someString");
+        expect(requestInfo).toEqual("load url from someString");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate("startState")(200, "loaded")).toEqual(".startState/200/loaded_mut");
+    });
+});
+describe("loadIfMarkerChangesFetcher", () => {
+    const id = (0, lens_1.identityOptics)();
+    const fetcher = (0, fetcher_1.markerFetcher)(id.focusQuery('desired'), (0, fetcher_1.holderIso)('holderForMarkerFetcher'), (desired, actual) => desired == actual, id.focusQuery('target'), marker => s => ["someUrlBasedOn" + marker, {}], "someFetcher");
+    it("should not load if the desired is undefined", () => {
+        expect(fetcher.shouldLoad({})).toEqual(["Desired Marker undefined"]);
+    });
+    it("should  load if the desired is defined and the target undefined", () => {
+        expect(fetcher.shouldLoad({ desired: "something" })).toEqual([]);
+    });
+    it("should not load if the selected and actual are the same", () => {
+        expect(fetcher.shouldLoad({ desired: "tag", target: { tags: "tag", t: "anything" } })).toEqual(["Markers match"]);
+    });
+    it("should load if the selected and actual are different, and the actual should be updated", () => {
+        let state = { target: { tags: "different", t: "something" }, desired: "newTag" };
+        expect(fetcher.shouldLoad(state)).toEqual(["Markers match"]);
+        const { requestInfo, requestInit, mutate } = fetcher.load(state);
+        expect(requestInfo).toEqual("someUrlBasedOnnewTag");
+        expect(requestInit).toEqual({});
+        expect(mutate(state)(200, "targetString")).toEqual({ target: { tags: "newTag", t: "targetString" }, desired: "newTag" });
+    });
+});
+describe("loadSelectedFetcher", () => {
+    const reqFn = (s) => ["someUrl", reqInit];
+    const f = (0, fetcher_1.loadSelectedFetcher)(s => [s.selState.selProfile, s.selState.selEntity], entityAndNameI, (0, lens_1.identityOptics)().focusQuery('entityAndName'), reqFn);
+    const fignoreerror = (0, fetcher_1.loadSelectedFetcher)(s => { throw Error('error loading'); }, entityAndNameI, (0, lens_1.identityOptics)().focusQuery('entityAndName'), reqFn, fetcher_1.not200MeansError, e => s => (Object.assign(Object.assign({}, s), { msg: "errorhandled" })));
+    const fDontIgnoreerror = (0, fetcher_1.loadSelectedFetcher)(s => { throw Error('error loading'); }, entityAndNameI, (0, lens_1.identityOptics)().focusQuery('entityAndName'), reqFn);
+    it("should have a description", () => {
+        expect(f.description).toEqual("selStateFetcher(holder=DirtyPrism(prism),target=Optional(I.focus?(entityAndName)),onError=false)");
+        expect(fignoreerror.description).toEqual("selStateFetcher(holder=DirtyPrism(prism),target=Optional(I.focus?(entityAndName)),onError=true)");
+        const f2 = (0, fetcher_1.loadSelectedFetcher)(s => [s.selState.selProfile, s.selState.selEntity], entityAndNameI, (0, lens_1.identityOptics)().focusQuery('entityAndName'), reqFn, fetcher_1.not200MeansError, e => s => (Object.assign(Object.assign({}, s), { msg: "errorhandled" })), "someDescription");
+        expect(f2.description).toEqual("someDescription");
+    });
+    it("should not load if any of the tags are undefined", () => {
+        expect(f.shouldLoad({ selState: {} })).toEqual(["not all tags defined"]);
+        expect(f.shouldLoad({ selState: { selEntity: 'someEntity' } })).toEqual(["not all tags defined"]);
+        expect(f.shouldLoad({ selState: { selProfile: 'someProfile' } })).toEqual(["not all tags defined"]);
+    });
+    it("should load if there is an error in reqFn and the onError is defined", () => {
+        let start = { selState: {} };
+        expect(fignoreerror.shouldLoad(start)).toEqual([]);
+        const { requestInfo, requestInit, mutate, useThisInsteadOfLoad } = fignoreerror.load(start);
+        expect(useThisInsteadOfLoad && useThisInsteadOfLoad(start)).toEqual({ "msg": "errorhandled", "selState": {} });
+    });
+    it("should still throw shouldload  error if there is an error and the ignoreError is true", () => {
+        expect(() => fDontIgnoreerror.shouldLoad({ selState: {} })).toThrow('error loading');
+    });
+    it("should load if the tags are  defined, and the target is undefined", () => {
+        let startState = { selState: { selEntity: 'someEntity', selProfile: 'someProfile' } };
+        expect(f.shouldLoad(startState)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = f.load(startState);
+        expect(requestInfo).toEqual("someUrl");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate(startState)(200, { "desc": "loaded" })).toEqual({
+            "entityAndName": {
+                "entity": { "desc": "loaded" },
+                "tags": ["someProfile", "someEntity"]
+            },
+            "selState": { "selEntity": "someEntity", "selProfile": "someProfile" }
+        });
+    });
+    it("should not load if the tags are  defined, and the tags are identical", () => {
+        let s = {
+            "entityAndName": {
+                "entity": { "desc": "oldDataSoShouldntChange" },
+                "tags": ["someProfile", "someEntity"]
+            },
+            "selState": { "selEntity": "someEntity", "selProfile": "someProfile" }
+        };
+        expect(f.shouldLoad(s)).toEqual(["tags match"]);
+    });
+    it("should load if the tags are  defined, and the tags are not identical", () => __awaiter(void 0, void 0, void 0, function* () {
+        let s = {
+            "entityAndName": {
+                "entity": { "desc": "oldDataWillChange" },
+                "tags": ["someProfile", "someEntity"]
+            },
+            "selState": { "selEntity": "someNewEntity", "selProfile": "someProfile" }
+        };
+        expect(f.shouldLoad(s)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = f.load(s);
+        expect(requestInfo).toEqual("someUrl");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate(s)(200, { "desc": "loaded" })).toEqual({
+            "entityAndName": {
+                "entity": { "desc": "loaded" },
+                "tags": ["someProfile", "someNewEntity"]
+            },
+            "selState": { "selEntity": "someNewEntity", "selProfile": "someProfile" }
+        });
+    }));
+    it("should handle a 404 if the onNotFound is defined", () => __awaiter(void 0, void 0, void 0, function* () {
+        let s = {
+            "entityAndName": {
+                "entity": { "desc": "oldDataWillChange" },
+                "tags": ["someProfile", "someEntity"]
+            },
+            "selState": { "selEntity": "someNewEntity", "selProfile": "someProfile" }
+        };
+        const f = (0, fetcher_1.loadSelectedFetcher)(s => [s.selState.selProfile, s.selState.selEntity], entityAndNameI, (0, lens_1.identityOptics)().focusQuery('entityAndName'), reqFn, (req, tags, s) => ({ entity: { "desc": "notFound" }, tags }));
+        const { requestInfo, requestInit, mutate } = f.load(s);
+        expect(mutate(s)(404, { "desc": "not used" })).toEqual({
+            "entityAndName": {
+                "entity": { "desc": "notFound" },
+                "tags": ["someProfile", "someNewEntity"]
+            },
+            "selState": { "selEntity": "someNewEntity", "selProfile": "someProfile" }
+        });
+    }));
+    it("should throw an error with a 404 if the onNotFound is not defined", () => __awaiter(void 0, void 0, void 0, function* () {
+        let s = {
+            "entityAndName": {
+                "entity": { "desc": "oldDataWillChange" },
+                "tags": ["someProfile", "someEntity"]
+            },
+            "selState": { "selEntity": "someNewEntity", "selProfile": "someProfile" }
+        };
+        const { requestInfo, requestInit, mutate } = f.load(s);
+        expect(() => mutate(s)(404, { "desc": "not used" })).toThrow("req someUrl [object Object] caused status code 404");
+    }));
+});
+const radioL = (0, lens_1.identityOptics)().focusQuery('radio');
+const radioTagL = (0, lens_1.identityOptics)().focusQuery('radioTag');
+function loaderForRadio(radio) {
+    return s => [`url for ${radio}`, reqInit];
+}
+const r1Fetcher = (0, fetcher_1.fetcherWhenUndefined)(radioL, loaderForRadio("1"));
+const r2Fetcher = (0, fetcher_1.fetcherWhenUndefined)(radioL, loaderForRadio("2"));
+const r3Fetcher = (0, fetcher_1.fetcherWhenUndefined)(radioL, loaderForRadio("3"));
+let radioGroup = ({
+    tag1: r1Fetcher,
+    tag2: r2Fetcher,
+    tag3: r3Fetcher,
+});
+describe("fetchRadioButton", () => {
+    let f = (0, fetcher_1.radioButtonFetcher)(s => s.selState.selRadioTag, radioTagL, (0, fetcher_1.fromTaggedFetcher)(radioGroup));
+    it("should have a description", () => {
+        expect(f.description).toEqual("fetchRadioButton(Optional(I.focus?(radioTag)))");
+    });
+    it("should not fetch if tag  is undefined", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(f.shouldLoad({ selState: {} })).toEqual(["Cannot find f"]);
+    }));
+    it("should  fetch if tag  is defined and legal and the target is undefined. It should set 'actual tag'", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(f.shouldLoad({ selState: { selRadioTag: "doesntexist" } })).toEqual(["Cannot find f"]);
+        let tag1State = { selState: { selRadioTag: "tag1" } };
+        expect(f.shouldLoad(tag1State)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = f.load(tag1State);
+        expect(requestInfo).toEqual("url for 1");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate(tag1State)(200, { r1: "r1value" })).toEqual({
+            "radio": { "r1": "r1value" },
+            "radioTag": "tag1",
+            "selState": { "selRadioTag": "tag1" }
+        });
+    }));
+    it("should fetch if the tag is defined, but a different value. It should set 'actualTag'", () => __awaiter(void 0, void 0, void 0, function* () {
+        let state = { selState: { selRadioTag: "tag2" }, radioTag: "tag1", radio: { "r1": "r1value" } };
+        expect(f.shouldLoad(state)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = f.load(state);
+        expect(requestInfo).toEqual("url for 2");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate(state)(200, { r2: "r2value" })).toEqual({
+            "radio": { "r2": "r2value" },
+            "radioTag": "tag2",
+            "selState": { "selRadioTag": "tag2" }
+        });
+    }));
+    it("should fetch if the tag is defined, but a different value. Even if the target is empty It should set 'actualTag'", () => __awaiter(void 0, void 0, void 0, function* () {
+        let state = { selState: { selRadioTag: "tag2" }, radioTag: "tag1" };
+        expect(f.shouldLoad(state)).toEqual([]);
+        const { requestInfo, requestInit, mutate } = f.load(state);
+        expect(requestInfo).toEqual("url for 2");
+        expect(requestInit).toEqual(reqInit);
+        expect(mutate(state)(200, { r2: "r2value" })).toEqual({
+            "radio": { "r2": "r2value" },
+            "radioTag": "tag2",
+            "selState": { "selRadioTag": "tag2" }
+        });
+    }));
+});
+describe("ifErrorFetcher", () => {
+    let rawError = (0, fetcher_1.fetcher)(shouldLoadTrue, s => { throw Error('msg'); }, "loadFalseF");
+    const fFalse = (0, fetcher_1.ifErrorFetcher)(loadFalseF, () => { throw Error('failed'); });
+    const fTrue = (0, fetcher_1.ifErrorFetcher)(loadTrueF, () => { throw Error('failed'); });
+    const fError = (0, fetcher_1.ifErrorFetcher)(rawError, e => s => `${e}+${s}`);
+    it("shouldLoad should act as the old one ", () => {
+        expect(fFalse.shouldLoad("'")).toEqual(["some reason"]);
+        expect(fTrue.shouldLoad("'")).toEqual([]);
+        expect(fError.shouldLoad("'")).toEqual([]);
+    });
+    it("load should act as old if there are no errors", () => {
+        const { requestInfo, requestInit, mutate, useThisInsteadOfLoad } = (fTrue.load('oldState'));
+        expect(requestInfo).toEqual('load url from oldState');
+        expect(requestInit).toEqual({ "keepalive": true });
+        expect(useThisInsteadOfLoad).toEqual(undefined);
+        expect(mutate("someValue")(200, "loaded")).toEqual('.someValue/200/loaded');
+    });
+    it("should return the on error when there was an error", () => {
+        const { requestInfo, requestInit, mutate, useThisInsteadOfLoad } = (fError.load('oldState'));
+        expect(requestInfo).toEqual('');
+        expect(requestInit).toEqual(undefined);
+        if (!useThisInsteadOfLoad)
+            throw Error();
+        expect(useThisInsteadOfLoad("oldstate")).toEqual("Error: msg+oldstate");
+    });
+});

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

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

package/dist/src/focusedPage.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const enzyme_1 = require("enzyme");
+const pages_1 = require("@focuson/pages");
+const page_fixture_1 = require("./page.fixture");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+let view = 'view';
+const nothingDisplayed = Object.assign(Object.assign({}, page_fixture_1.emptyState), { messages: [], pageSelection: [{ pageName: 'nothing', pageMode: view, time: 'now' }] });
+describe("selectedPage", () => {
+    // it ( "should display zero pages", () => {
+    //   const state = lensState<PageSpecState, ContextForTest> ( rootState, () => {}, 'displayMain / focusedPage', context )
+    //   const comp = shallow ( <SelectedPage state={state}/> )
+    //   // expect ( comp.html () ).toEqual ( '' )
+    //   expect ( comp.text () ).toEqual ( "" )
+    // } )
+    it("should display one page", () => {
+        const state = (0, page_fixture_1.lensStateWith)(page_fixture_1.dataDefinedState, () => { }, ['firstPage', 'edit', undefined]);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(pages_1.SelectedPage, { state: state }));
+        expect(comp.html()).toEqual("<div class=\"combine\"><div class=\"focus-page\"><div id=\"default_template\">" +
+            "<h1>[firstPageTitle]:</h1>" +
+            "<p>firstPage[one]/edit</p>" +
+            "</div></div></div>");
+    });
+    it("should display two pages", () => {
+        const state = (0, page_fixture_1.lensStateWith)(page_fixture_1.dataDefinedState, () => { }, ['firstPage', 'edit', undefined], ['secondPage', 'view', undefined]);
+        const comp = (0, enzyme_1.shallow)((0, jsx_runtime_1.jsx)(pages_1.SelectedPage, { state: state }));
+        // expect ( comp.html () ).toEqual ( '' )
+        expect(comp.html()).toEqual('<div class="combine"><div class="focus-page"><div id="default_template">' +
+            '<h1>[firstPageTitle]:</h1>' +
+            '<p>firstPage[one]/edit</p></div></div>' +
+            '<div class="focus-page"><div id="default_template">' +
+            '<h1>[secondPageTitle]:</h1>' +
+            '<p>secondPage[two]/view</p></div></div></div>');
+    });
+    it("should display three pages", () => {
+        const state = (0, page_fixture_1.lensStateWith)(page_fixture_1.dataDefinedState, () => { }, ['firstPage', 'edit', undefined], ['secondPage', 'view', undefined], ['modalData', 'edit', undefined]);
+        const comp = (0, enzyme_1.shallow)((0, jsx_runtime_1.jsx)(pages_1.SelectedPage, { state: state }));
+        // expect ( comp.html () ).toEqual ( '' )
+        expect(comp.html()).toEqual('<div class="combine"><div class="focus-page"><div id="default_template">' +
+            '<h1>[firstPageTitle]:</h1>' +
+            '<p>firstPage[one]/edit</p></div></div>' +
+            '<div class="focus-page"><div id="default_template">' +
+            '<h1>[secondPageTitle]:</h1>' +
+            '<p>secondPage[two]/view</p></div></div>' +
+            '<div class="focus-page"><div id="default_template">' +
+            '<h1>[modalDataTitle]:</h1>' +
+            '<p>modalData[x]/edit</p></div></div></div>');
+    });
+    it("shouldbe using the combine for multiple pages", () => {
+        const state = (0, page_fixture_1.lensStateWith)(page_fixture_1.dataDefinedState, () => { }, ['firstPage', 'edit', undefined], ['secondPage', 'view', undefined], ['modalData', 'edit', undefined]);
+        const comp = (0, enzyme_1.shallow)((0, jsx_runtime_1.jsx)(pages_1.SelectedPage, { state: state }));
+        expect(comp.find('.combine').length).toEqual(1);
+    });
+    it("display loading when no data", () => {
+        const state = (0, page_fixture_1.lensStateWith)(page_fixture_1.rootState, () => { }, ['firstPage', 'edit', undefined], ['secondPage', 'view', undefined], ['modalData', 'edit', undefined]);
+        const comp = (0, enzyme_1.shallow)((0, jsx_runtime_1.jsx)(pages_1.SelectedPage, { state: state }));
+        expect(comp.html()).toEqual('<div class="combine">' +
+            '<div class="focus-page"><div id="default_template"><h1>[firstPageTitle]:</h1>' +
+            '<div><p>Loading</p><span class="tooltip-wrap">' +
+            '<button class="button" id="loading.cancel" aria-errormessage="loading.cancel.error" aria-invalid="false">Cancel </button>' +
+            '<ul hidden="" class="errormessage tooltip" id="loading.cancel.error"></ul></span></div></div></div><div class="focus-page">' +
+            '<div id="default_template"><h1>[secondPageTitle]:</h1><div><p>Loading</p>' +
+            '<span class="tooltip-wrap"><button class="button" id="loading.cancel" aria-errormessage="loading.cancel.error" aria-invalid="false">Cancel </button>' +
+            '<ul hidden="" class="errormessage tooltip" id="loading.cancel.error"></ul></span></div></div></div>' +
+            '<div class="focus-page"><div id="default_template">' +
+            '<h1>[modalDataTitle]:</h1><p>modalData[x]/edit</p></div></div></div>');
+    });
+});

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

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

package/dist/src/labelAnd.spec.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+const state_1 = require("@focuson/state");
+const context_fixture_1 = require("./context.fixture");
+const enzyme_1 = require("enzyme");
+const form_components_1 = require("@focuson/form_components");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+const empty = {
+    messages: [], pageSelection: [], restCommands: [], tags: {}
+};
+function labelAndString(label, string, className) {
+    const state = (0, state_1.lensState)(Object.assign(Object.assign({}, empty), { string }), () => { }, '', (0, context_fixture_1.context)());
+    // @ts-ignore
+    const focusedState = state.focusOn('string');
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.LabelAndStringInput, { id: 'someId', state: focusedState, label: label, allButtons: {}, className: className }));
+}
+function labelAndNumber(label, number, className) {
+    const state = (0, state_1.lensState)(Object.assign(Object.assign({}, empty), { number }), () => { }, '', (0, context_fixture_1.context)());
+    // @ts-ignore
+    const focusedState = state.focusOn('number');
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.LabelAndNumberInput, { id: 'someId', state: focusedState, label: label, allButtons: {}, className: className }));
+}
+function labelAndBoolean(label, boolean, className) {
+    const state = (0, state_1.lensState)(Object.assign(Object.assign({}, empty), { boolean }), () => { }, '', (0, context_fixture_1.context)());
+    // @ts-ignore
+    const focusedState = state.focusOn('boolean');
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.LabelAndBooleanInput, { id: 'someId', state: focusedState, label: label, allButtons: {}, className: className }));
+}
+function labelAndYNBoolean(label, yn, className) {
+    const state = (0, state_1.lensState)(Object.assign(Object.assign({}, empty), { yn }), () => { }, '', (0, context_fixture_1.context)());
+    // @ts-ignore
+    const focusedState = state.focusOn('yn');
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.LabelAndYNBooleanInput, { id: 'someId', state: focusedState, label: label, allButtons: {}, className: className }));
+}
+describe('LabelAndString', () => {
+    it('should render with data', () => {
+        expect(labelAndString('someLabel', 'someString').html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class=""><input class="input" type="text" id="someId" data-validationmessage="someLabel" value="someString"></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with html label', () => {
+        expect(labelAndString('some <b>bold</b> Label', 'someString').html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">some <b>bold</b> Label</label><div class=""><input class="input" type="text" id="someId" data-validationmessage="some <b>bold</b> Label" value="someString"></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with undefined', () => {
+        // @ts-ignore
+        const string = undefined;
+        expect(labelAndString('someLabel', string).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class=""><input class="input" type="text" id="someId" data-validationmessage="someLabel" value=""></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with null', () => {
+        // @ts-ignore
+        const string = null;
+        expect(labelAndString('someLabel', string).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class=""><input class="input" type="text" id="someId" data-validationmessage="someLabel" value=""></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should include a className if specified', () => {
+        // @ts-ignore
+        const number = 'someString';
+        expect(labelAndString('someLabel', number, 'theClass').html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="theClass"><input class="input" type="text" id="someId" data-validationmessage="someLabel" value="someString"></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+});
+describe('LabelAndNumber', () => {
+    it('should render with data', () => {
+        expect(labelAndNumber('someLabel', 123).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class=""><input class="input" type="number" id="someId" data-validationmessage="someLabel" value="123"></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with html label', () => {
+        expect(labelAndNumber('some <b>bold</b> Label', 123).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">some <b>bold</b> Label</label><div class=""><input class="input" type="number" id="someId" data-validationmessage="some <b>bold</b> Label" value="123"></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with undefined', () => {
+        // @ts-ignore
+        const number = undefined;
+        expect(labelAndNumber('someLabel', number).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class=""><input class="input" type="number" id="someId" data-validationmessage="someLabel" value=""></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with null', () => {
+        // @ts-ignore
+        const number = null;
+        expect(labelAndNumber('someLabel', number).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class=""><input class="input" type="number" id="someId" data-validationmessage="someLabel" value=""></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should include a className if specified', () => {
+        // @ts-ignore
+        const number = 123;
+        expect(labelAndNumber('someLabel', number, 'theClass').html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="theClass"><input class="input" type="number" id="someId" data-validationmessage="someLabel" value="123"></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+});
+describe('LabelAndBoolean', () => {
+    it('should render with data - true', () => {
+        expect(labelAndBoolean('someLabel', true).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="checkbox-container"><input type="checkbox" id="someId" data-validationmessage="someLabel" class="input" checked=""><span class="checkmark"></span></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with data - false', () => {
+        expect(labelAndBoolean('someLabel', false).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="checkbox-container"><input type="checkbox" id="someId" data-validationmessage="someLabel" class="input"><span class="checkmark"></span></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with undefined', () => {
+        // @ts-ignore
+        const number = undefined;
+        expect(labelAndBoolean('someLabel', number).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="checkbox-container"><input type="checkbox" id="someId" data-validationmessage="someLabel" class="input"><span class="checkmark"></span></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should render with null', () => {
+        // @ts-ignore
+        const number = null;
+        expect(labelAndBoolean('someLabel', number).html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="checkbox-container"><input type="checkbox" id="someId" data-validationmessage="someLabel" class="input"><span class="checkmark"></span></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+    it('should include a className if specified', () => {
+        // @ts-ignore
+        const number = true;
+        expect(labelAndBoolean('someLabel', number, 'theClass').html()).toEqual('<div class="labelValueButton "> <label for="someId" class="input-label">someLabel</label><div class="checkbox-container theClass"><input type="checkbox" id="someId" data-validationmessage="someLabel" class="input" checked=""><span class="checkmark"></span></div><div id="someId.error" hidden="" class=""></div></div>');
+    });
+});

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

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

package/dist/src/labelAndDateInput.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const form_components_1 = require("@focuson/form_components");
+const firstMay2020 = new Date('2020/05/01');
+describe("parseDate", () => {
+    it("should parse yyyy/MM/dd", () => {
+        expect((0, form_components_1.parseDate)('prefix', 'yyyy/MM/dd')('2020/05/01')).toEqual(firstMay2020);
+        expect((0, form_components_1.parseDate)('prefix', 'yyyy/MM/dd')('2020-05-01')).toEqual(firstMay2020);
+    });
+    it("should parse yyyy-MM-dd", () => {
+        expect((0, form_components_1.parseDate)('prefix', 'yyyy-MM-dd')('2020-05-01')).toEqual(firstMay2020);
+        expect((0, form_components_1.parseDate)('prefix', 'yyyy-MM-dd')('2020-05-01')).toEqual(firstMay2020);
+    });
+    it("should parse dd/yyyy/MM", () => {
+        expect((0, form_components_1.parseDate)('prefix', 'dd/yyyy-MM')('01-2020-05')).toEqual(firstMay2020);
+        expect((0, form_components_1.parseDate)('prefix', 'dd/yyyy-MM')('01/2020/05')).toEqual(firstMay2020);
+    });
+    it("should parse dd-yyyy-MM", () => {
+        expect((0, form_components_1.parseDate)('prefix', 'dd-yyyy-MM')('01-2020-05')).toEqual(firstMay2020);
+        expect((0, form_components_1.parseDate)('prefix', 'dd-yyyy-MM')('01-2020-05')).toEqual(firstMay2020);
+    });
+    it("should parse dd/MM/yyyy", () => {
+        expect((0, form_components_1.parseDate)('prefix', 'dd-MM-yyyy')('01-05-2020')).toEqual(firstMay2020);
+        expect((0, form_components_1.parseDate)('prefix', 'dd-MM-yyyy')('01/05/2020')).toEqual(firstMay2020);
+    });
+});

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

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