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

package/dist/src/page.fixture.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = exports.pageDetails = exports.invalidPageState = exports.secondPageSelectedState = exports.firstPageWithFirstTime = exports.firstPageSelectedState = exports.dataDefinedState = exports.rootState = exports.emptyState = void 0;
+exports.stateWith = stateWith;
+exports.stateWithFirstTimes = stateWithFirstTimes;
+exports.lensStateWith = lensStateWith;
+exports.pageSpecStateConfig = pageSpecStateConfig;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const state_1 = require("@focuson/state");
+const lens_1 = require("@focuson/lens");
+const pages_1 = require("@focuson/pages");
+const utils_1 = require("@focuson/utils");
+const focuson_1 = require("@focuson/focuson");
+exports.emptyState = {
+    pageSelection: [], messages: [], tags: {}, restCommands: []
+};
+exports.rootState = Object.assign(Object.assign({}, exports.emptyState), { messages: [], pageSelection: [], tempData: 'x' });
+exports.dataDefinedState = Object.assign(Object.assign({}, exports.emptyState), { firstPage: 'one', secondPage: { fromApi: 'two' }, messages: [], pageSelection: [], tempData: 'x' });
+exports.firstPageSelectedState = stateWith(exports.rootState, ['firstPage', 'view', undefined]);
+exports.firstPageWithFirstTime = stateWithFirstTimes(exports.rootState, ['firstPage', 'view', undefined]);
+exports.secondPageSelectedState = stateWith(exports.rootState, ['secondPage', 'view', undefined]);
+exports.invalidPageState = stateWithFirstTimes(exports.rootState, ['unknownpage', 'view', undefined]);
+function stateWith(main, ...nameAndModes) {
+    return Object.assign(Object.assign({}, main), { pageSelection: nameAndModes.map(([pageName, pageMode, rest]) => ({ pageName, pageMode, rest, time: 'now' })) });
+}
+function stateWithFirstTimes(main, ...nameAndModes) {
+    return Object.assign(Object.assign({}, main), { pageSelection: nameAndModes.map(([pageName, pageMode, rest]) => ({ pageName, pageMode, firstTime: true, rest, time: 'now' })) });
+}
+function lensStateWith(main, setMain, ...nameAndModes) {
+    return (0, state_1.lensState)(stateWith(main, ...nameAndModes), setMain, 'displayMain / focusedPage', exports.context);
+}
+const DisplayPageSpecState = (prefix, haveTopRightCrossToCancel) => (0, pages_1.focusedPage)(() => ({ title: `[${prefix}Title]:` }), haveTopRightCrossToCancel === true)((s, d, mode) => ((0, jsx_runtime_1.jsxs)("p", { children: [prefix, "[", d, "]/", mode] })));
+function pageSpecStateConfig() {
+    // @ts-ignore  There is some crazy thing going on here around SimpleMessage and SimpleMessage[].
+    let pageConfig = (0, pages_1.simpleMessagesPageConfig)(pages_1.Loading);
+    return pageConfig;
+}
+exports.pageDetails = {
+    firstPage: { pageType: 'MainPage', config: pageSpecStateConfig(), lens: (0, lens_1.identityOptics)().focusQuery('firstPage'), pageFunction: DisplayPageSpecState('firstPage'), pageMode: 'edit' },
+    clearAtStart: { pageType: 'MainPage', config: pageSpecStateConfig(), lens: (0, lens_1.identityOptics)().focusQuery('firstPage'), pageFunction: DisplayPageSpecState('firstPage'), clearAtStart: true, pageMode: 'edit' },
+    init: {
+        pageType: 'MainPage', config: pageSpecStateConfig(), lens: (0, lens_1.identityOptics)().focusQuery('firstPage'), pageFunction: DisplayPageSpecState('firstPage'),
+        initialValue: [{ command: 'set', path: '~', value: "Initial Value" }], pageMode: 'edit'
+    },
+    secondPage: { pageType: 'MainPage', config: pageSpecStateConfig(), lens: (0, lens_1.identityOptics)().focusQuery('secondPage').focusQuery('fromApi'), pageFunction: DisplayPageSpecState('secondPage'), clearAtStart: true, pageMode: 'edit' },
+    modalData: {
+        pageType: 'MainPage', config: pageSpecStateConfig(), lens: (0, lens_1.identityOptics)().focusQuery('tempData'), pageFunction: DisplayPageSpecState('modalData'),
+        initialValue: [{ command: 'set', path: '~', value: "Initial Value" }], pageMode: 'edit'
+    },
+    error: {
+        pageType: 'MainPage', config: pageSpecStateConfig(), lens: (0, lens_1.identityOptics)().focusQuery('tempData'), pageFunction: DisplayPageSpecState('error'), clearAtStart: true,
+        initialValue: [{ command: 'set', path: '~', value: "Initial Value" }], pageMode: 'edit'
+    },
+};
+exports.context = (0, focuson_1.defaultPageSelectionAndRestCommandsContext)(exports.pageDetails, {}, {}, {}, utils_1.testDateFn, true);

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

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

package/dist/src/pageSelection.spec.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const lens_1 = require("@focuson/lens");
+const focuson_1 = require("@focuson/focuson");
+const state_1 = require("@focuson/state");
+const pages_1 = require("@focuson/pages");
+const utils_1 = require("@focuson/utils");
+let pageSelection = { pageName: 'a', pageMode: 'view', time: 'now' };
+const x = { g: 1, h: ['h0', 'h1'], i: { j: 2 } };
+const textForLabelState = {
+    messages: [],
+    tags: {},
+    pageSelection: [pageSelection],
+    restCommands: [],
+    a: {
+        b: { c: 'cValue', x },
+        d: ['zero', 'one', 'two', 'three', 'four', 'five'],
+        selecteda: 3,
+        e: 5,
+        f: 6,
+        holdse: 'e',
+        holdsf: 'e',
+    },
+    selected: 2,
+    holdseinroot: 'e'
+};
+const identity = lens_1.Lenses.identity();
+const aL = identity.focusQuery('a');
+const abL = identity.focusOn('a').focusQuery('b');
+const abxL = identity.focusOn('a').focusQuery('b').focusQuery('x');
+const pageDetails = {
+    a: { config: {}, pageType: 'MainPage', pageFunction: () => (0, jsx_runtime_1.jsx)("span", {}), lens: aL, pageMode: 'edit' }
+};
+const state = (0, state_1.lensState)(textForLabelState, s => { }, '', (0, focuson_1.defaultPageSelectionAndRestCommandsContext)(pageDetails, {}, {}, {}, utils_1.testDateFn, true));
+// const fromPath: ( path: string[], description?: string ) => Optional<TextForLabelState, any> = fromPathFor ( state )
+let stateabx = state.copyWithLens(abxL);
+const fromL = (path) => (0, pages_1.fromPathGivenState)(stateabx)(path);
+const from = (path) => fromL(path).getOption(state.main);
+const set = (path, value) => fromL(path).set(state.main, value);
+const ps1 = { pageName: 'one', pageMode: 'view', time: 'time1' };
+const ps2 = { pageName: 'two', pageMode: 'view', time: 'time2' };
+const ps3 = { pageName: 'three', pageMode: 'view', time: 'time3' };
+const psNew = { pageName: 'new', pageMode: 'view', time: 'timeNew' };
+describe("applyPageOps", () => {
+    describe("should select - replace whatever is there with this page", () => {
+        it("should select with no current pages", () => {
+            expect((0, pages_1.applyPageOps)('select', psNew)([])).toEqual([psNew]);
+        });
+        it("should select with one or more pages", () => {
+            expect((0, pages_1.applyPageOps)('select', psNew)([ps1])).toEqual([psNew]);
+            expect((0, pages_1.applyPageOps)('select', psNew)([ps1, ps2, ps3])).toEqual([psNew]);
+        });
+    });
+    describe("should popup - add this page", () => {
+        it("should popup with no current pages", () => {
+            expect((0, pages_1.applyPageOps)('popup', psNew)([])).toEqual([psNew]);
+        });
+        it("should popup with no one pages", () => {
+            expect((0, pages_1.applyPageOps)('popup', psNew)([ps1])).toEqual([ps1, psNew]);
+            expect((0, pages_1.applyPageOps)('popup', psNew)([ps1, ps2])).toEqual([ps1, ps2, psNew]);
+            expect((0, pages_1.applyPageOps)('popup', psNew)([ps1, ps2, ps3])).toEqual([ps1, ps2, ps3, psNew]);
+        });
+    });
+    describe("should replace - replace the top page", () => {
+        it("should replace with no current pages", () => {
+            expect((0, pages_1.applyPageOps)('replace', psNew)([])).toEqual([psNew]);
+        });
+        it("should replace the top page", () => {
+            expect((0, pages_1.applyPageOps)('replace', psNew)([ps1])).toEqual([psNew]);
+            expect((0, pages_1.applyPageOps)('replace', psNew)([ps1, ps2])).toEqual([ps1, psNew]);
+            expect((0, pages_1.applyPageOps)('replace', psNew)([ps1, ps2, ps3])).toEqual([ps1, ps2, psNew]);
+        });
+    });
+});
+describe("fromPathStringFor. Page is 'a'. The current lens is a/b/x", () => {
+    it("should default to a path from 'here'. i.e. a/b/x'", () => {
+        expect(from("g")).toEqual(1);
+        expect(set("g", 1).a.b.x).toEqual({ "g": 1, "h": ["h0", "h1"], "i": { "j": 2 } });
+        expect(from("i/j")).toEqual(2);
+        expect(set("i/j", 5).a.b.x.i).toEqual({ "j": 5 });
+    });
+    it("should allow / as a 'root' marker", () => {
+        expect(from("/a/e")).toEqual(5);
+        expect(from("/a/b/c")).toEqual('cValue');
+        expect(set("/a/b/c", 'xx').a.b).toEqual({ "c": "xx", x });
+    });
+    it("should allow ~  as a 'home' marker i.e. current main page", () => {
+        expect(from("~/e")).toEqual(5);
+        expect(from("~/b/c")).toEqual('cValue');
+        expect(set("~/b/c", 'x').a).toEqual({
+            "b": { "c": "x", "x": { "g": 1, "h": ["h0", "h1"], "i": { "j": 2 } } },
+            "d": ["zero", "one", "two", "three", "four", "five"],
+            "e": 5, "f": 6, "holdse": "e", "holdsf": "e", "selecteda": 3
+        });
+    });
+    it("should allow [ .. ] notation with numbers - default", () => {
+        expect(from("h[0]")).toEqual('h0');
+        expect(set("h[0]", 'xx').a.b.x.h).toEqual(["xx", "h1"]);
+        expect(from("h[0][0]")).toEqual('h');
+        expect(from("h[0][1]")).toEqual('0');
+    });
+    it("should allow [ .. ] notation with numbers - root", () => {
+        expect(from("/a/b/c[0]")).toEqual('c');
+        expect(from("/a/b/c[1]")).toEqual('V');
+        expect(from("/a/b/c[2]")).toEqual('a');
+        expect(from("/a/d[2]")).toEqual('two');
+    });
+    it("should allow [ .. ] notation with numbers - page", () => {
+        expect(from("~/b/c[0]")).toEqual('c');
+        expect(from("~/b/c[1]")).toEqual('V');
+        expect(from("~/b/c[2]")).toEqual('a');
+        expect(from("~/d[2]")).toEqual('two');
+    });
+    it("should allow { ... } notation with special marker {last}", () => {
+        expect(from("/a/d[$last]")).toEqual('five');
+        expect(fromL("/a/d[$last]").set(textForLabelState, 'x').a.d).toEqual(["zero", "one", "two", "three", "four", "x"]);
+    });
+    it("should allow [ ... ] notation with special marker {append}", () => {
+        expect(from("/a/d[$append]")).toEqual(undefined);
+        expect(fromL("/a/d[$append]").set(textForLabelState, 'x').a.d).toEqual(["zero", "one", "two", "three", "four", "five", "x"]);
+    });
+    it("should allow a path in the [ .. ] notation - default", () => {
+        expect(fromL("/a/d[selected]").description).toEqual('I.focus?(a).focus?(d).chainCalc(I.focusOn(a).focus?(b).focus?(x).focus?(selected))');
+        expect(fromL("/a/d[/selected]").description).toEqual('I.focus?(a).focus?(d).chainCalc(I.focus?(selected))');
+    });
+    it("should allow a path in the [ .. ] notation - root", () => {
+        expect(from("/a/d[/selected][/selected]")).toEqual('o');
+        expect(from("/a/d[/selected]")).toEqual('two');
+        expect(from("/a/d[/a/selecteda]")).toEqual('three');
+        expect(from("/a/d[/selected][1]")).toEqual('w');
+    });
+    it("should allow a path in the [ .. ] notation - home", () => {
+        expect(from("/a/d[~/e]")).toEqual('five');
+        expect(from("/a/d[~/selecteda]")).toEqual('three');
+    });
+});
+//Note that the raw behaviour is tested about. Here we just check we make suitable lens
+describe("fromPathFromRaw", () => {
+    it("should make lens", () => {
+        const fromPath = (0, pages_1.fromPathFromRaw)((0, pages_1.pageSelectionlens)(), pageDetails)(textForLabelState);
+        expect(fromPath("~/b/c").description).toEqual('I.focus?(a).focus?(b).focus?(c)');
+        expect(fromPath("/a/b/c").description).toEqual('I.focus?(a).focus?(b).focus?(c)');
+        expect(() => fromPath("b/c").description).toThrow("Error parsing 'b/c'. Cannot find initial  ''");
+    });
+});

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

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

package/dist/src/post.spec.js

@@ -0,0 +1,84 @@
+"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 lens_1 = require("@focuson/lens");
+const poster_1 = require("@focuson/poster");
+const identityL = lens_1.Lenses.identity("testPostState");
+const postDebugL = identityL.focusQuery('debug');
+const errorL = identityL.focusQuery('errors');
+const postCommandsL = identityL.focusQuery('postCommands');
+function urlFn(expected) {
+    return (args) => {
+        expect(args).toEqual(expected);
+        return ["/" + args, undefined];
+    };
+}
+const onePostDetails = { urlFn: urlFn("args1"), targetLn: identityL.focusQuery('one'), shape: s => s + "_1", errorFn: (0, poster_1.addDebugErrorMessage)(errorL) };
+const twoPostDetails = { urlFn: urlFn("args2"), targetLn: identityL.focusQuery('two'), shape: s => s + "_2", errorFn: (0, poster_1.addDebugErrorMessage)(errorL) };
+const threePostDetails = { urlFn: urlFn("args3"), targetLn: identityL.focusQuery('three'), shape: s => s + "_3", errorFn: (0, poster_1.addDebugErrorMessage)(errorL) };
+const fourPostDetails = { urlFn: urlFn("args4"), targetLn: identityL.focusQuery('four'), shape: s => s + "_4", errorFn: (0, poster_1.addDebugErrorMessage)(errorL) };
+const postDetails = {
+    one: onePostDetails,
+    two: twoPostDetails,
+    three: threePostDetails,
+    four: fourPostDetails
+};
+function testFetchFn(requestInfo, requestInit) {
+    if (requestInfo === "/args1")
+        return Promise.resolve([200, "oneRes"]);
+    if (requestInfo === "/args2")
+        return Promise.resolve([200, "twoRes"]);
+    if (requestInfo === "/args3")
+        return Promise.resolve([200, "threeRes"]);
+    if (requestInfo === "/args4")
+        return Promise.resolve([200, "fourRes"]);
+    throw 'failed';
+}
+function testNon200FetchFn(requestInfo, requestInit) {
+    if (requestInfo === "/args1")
+        return Promise.resolve([200, "oneRes"]);
+    if (requestInfo === "/args2")
+        return Promise.resolve([400, "twoRes"]);
+    if (requestInfo === "/args3")
+        return Promise.resolve([500, "threeRes"]);
+    if (requestInfo === "/args4")
+        return Promise.reject("failed");
+    throw 'failed';
+}
+const poster = (0, poster_1.post)(testFetchFn, postDetails, postCommandsL, postDebugL);
+const errorPoster = (0, poster_1.post)(testNon200FetchFn, postDetails, postCommandsL, postDebugL);
+const fourPostCommands = [
+    { poster: 'one', args: "args1" },
+    { poster: 'two', args: "args2" },
+    { poster: 'three', args: "args3" },
+    { poster: 'four', args: "args4" }
+];
+const emptyState = { errors: [], debug: { postDebug: true } };
+describe('addDebugErrorMessage', () => {
+    it("should add an error message to the state", () => {
+        expect((0, poster_1.addDebugErrorMessage)(errorL)(emptyState, "someDetail", "someArgs", 200, "someresp")).toEqual({ "debug": { "postDebug": true }, "errors": ["someDetail \"someArgs\" Status(200) Resp: someresp)"] });
+    });
+});
+describe("post", () => {
+    it("should return a promise of the input state if no post commands", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield poster(emptyState)).toEqual(emptyState);
+    }));
+    it("should aggreagate successful posts, removing existing postcommands ", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield poster(Object.assign(Object.assign({}, emptyState), { postCommands: fourPostCommands }))).toEqual(Object.assign(Object.assign({}, emptyState), { "postCommands": [], "one": "oneRes_1", "two": "twoRes_2", "three": "threeRes_3", "four": "fourRes_4" }));
+    }));
+    it("should aggreagate successful posts and non200 results, removing existing postcommands", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield errorPoster(Object.assign(Object.assign({}, emptyState), { postCommands: fourPostCommands }))).toEqual(Object.assign(Object.assign({}, emptyState), { errors: [
+                "two \"args2\" Status(400) Resp: twoRes)",
+                "three \"args3\" Status(500) Resp: threeRes)",
+                "four \"args4\" Status(undefined) Resp: failed)"
+            ], "postCommands": [], "one": "oneRes_1" }));
+    }));
+});

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

@@ -0,0 +1,2 @@
+export type Context = 'context';
+export declare const context = "context";

package/dist/src/postButton.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const state_1 = require("@focuson/state");
+const enzyme_1 = require("enzyme");
+const poster_1 = require("@focuson/poster");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+exports.context = 'context';
+describe("post button", () => {
+    it("should render with an id and title", () => {
+        const state = (0, state_1.lensState)({ postCommands: [] }, (s) => { }, 'postbutton', exports.context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(poster_1.PostButton, { state: state, text: 'someTitle', id: 'someId', poster: 'somePoster', args: 'someArgs', postCommandL: (0, poster_1.postCommandsL)() }));
+        const button = comp.find("button");
+        expect(button.text()).toEqual('someTitle');
+    });
+    it("should change the state to have a model when clicked", () => {
+        var remembered = { postCommands: [] };
+        const state = (0, state_1.lensState)({ postCommands: [] }, (s) => { remembered = s; }, 'PostButton', exports.context);
+        const comp = (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(poster_1.PostButton, { state: state, text: 'someTitle', id: 'someId', poster: 'somePoster', args: 'someArgs', postCommandL: (0, poster_1.postCommandsL)() }));
+        const button = comp.find("button");
+        button.simulate('click');
+        expect(remembered).toEqual({ "postCommands": [{ poster: "somePoster", args: "someArgs" }] });
+    });
+});

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

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

package/dist/src/preMutate.spec.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//** This clears up the state if it is the first time something is called */
+const pages_1 = require("@focuson/pages");
+const page_fixture_1 = require("./page.fixture");
+const focuson_1 = require("@focuson/focuson");
+const config = (0, focuson_1.makeModalProcessorsConfig)(page_fixture_1.firstPageSelectedState, page_fixture_1.context);
+const preMutate = (0, pages_1.preMutateForPages)(page_fixture_1.context, config);
+let viewPageMode = "view";
+describe("preMutateForPages", () => {
+    it("should throw an error if the page is not valid", () => {
+        expect(() => preMutate(page_fixture_1.invalidPageState)).toThrow('Could not find details for unknownpage. LegalValues are firstPage,clearAtStart,init,secondPage,modalData,error');
+    });
+    it("should return the state if firstTime not true", () => {
+        expect(preMutate(page_fixture_1.firstPageSelectedState)).toEqual(page_fixture_1.firstPageSelectedState);
+    });
+    it("should not clear the state if first time is false", () => {
+        expect(preMutate(Object.assign(Object.assign({}, (0, page_fixture_1.stateWith)(page_fixture_1.rootState, ['clearAtStart', 'view', undefined])), { firstPage: 'data' }))).toEqual({
+            "messages": [],
+            "pageSelection": [{ "pageMode": "view", "pageName": "clearAtStart", "time": "now", }],
+            "tags": {},
+            restCommands: [],
+            firstPage: 'data',
+            "tempData": "x"
+        });
+    });
+    it("should clear the firstTime, and clear the domain, if firstTime true, and clearAtStart is true", () => {
+        expect(preMutate((0, page_fixture_1.stateWithFirstTimes)(page_fixture_1.rootState, ['clearAtStart', 'view', undefined])))
+            .toEqual({
+            "messages": [],
+            firstPage: undefined,
+            restCommands: [],
+            "pageSelection": [{ "firstTime": false, "pageMode": "view", "pageName": "clearAtStart", "time": "now", }],
+            "tags": {},
+            "tempData": "x"
+        });
+    });
+    it("should clear the firstTime, and set the domain to the initial value, if firstTime true, and initialValue is defined", () => {
+        expect(preMutate(Object.assign(Object.assign({}, (0, page_fixture_1.stateWithFirstTimes)(page_fixture_1.rootState, ['init', 'view', undefined])), { firstPage: "some Data" })))
+            .toEqual({
+            "firstPage": "Initial Value",
+            "messages": [],
+            restCommands: [],
+            "pageSelection": [{ "firstTime": false, "pageMode": "view", "pageName": "init", "time": "now", }],
+            "tags": {},
+            "tempData": "x"
+        });
+    });
+    it("should not set the domain to the initial value, if firstTime is false, and initialValue is defined", () => {
+        expect(preMutate(Object.assign(Object.assign({}, (0, page_fixture_1.stateWith)(page_fixture_1.rootState, ['init', 'view', undefined])), { firstPage: "some Data" })))
+            .toEqual({
+            "firstPage": "some Data",
+            "messages": [],
+            restCommands: [],
+            "pageSelection": [{ "pageMode": "view", "pageName": "init", "time": "now", }],
+            "tags": {},
+            "tempData": "x"
+        });
+    });
+    it("should throw an error if first time is true and both clearAtStart and initialValue are set", () => {
+        expect(() => preMutate((0, page_fixture_1.stateWithFirstTimes)(page_fixture_1.rootState, ['error', 'view', undefined]))).toThrow('page error has both clear at start and initialValue set');
+    });
+});

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

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

package/dist/src/radioButton.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+const enzyme_1 = require("enzyme");
+const form_components_1 = require("@focuson/form_components");
+const state_1 = require("@focuson/state");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+const enumForTest = {
+    a: "A",
+    b: "B"
+};
+function makeComponent(state, setMain) {
+    // @ts-ignore - because we aren't using any of the focus on context stuff
+    let lensState1 = (0, state_1.lensState)(state, setMain, '', {});
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.LabelAndRadio, { label: 'someLabel', allButtons: {}, enums: enumForTest, state: lensState1.focusOn('a'), id: 'someId' }));
+}
+describe("LabelAndRadio", () => {
+    it("should render", () => {
+        expect(makeComponent({ a: undefined }, () => { }).html().replace(/"/g, "'")).toEqual("<div class='labelRadioButton'><label class='input-label'>someLabel</label>" +
+            "<div class='radio-group-container ' id='someId'><div class='radio-container   '>" +
+            "<input id='someIdA' type='radio' name='someId' value=''><span class='checkmark'></span>" +
+            "<label for='someIdA' class='input-label'>A</label></div><div class='radio-container   '>" +
+            "<input id='someIdB' type='radio' name='someId' value=''>" +
+            "<span class='checkmark'></span><label for='someIdB' class='input-label'>B</label></div></div></div>");
+    });
+    it("should render for value a", () => {
+        let html = makeComponent({ a: 'a' }, () => { }).html().replace(/"/g, "'");
+        expect(html).toContain("<div class='radio-container  checked '><input id='someIdA' type='radio' name='someId' value='a' checked=''>");
+        expect(html).not.toContain("<div class='radio-container  checked '><input id='someIdB'");
+    });
+    it("should render for invalid value", () => {
+        let html = makeComponent({ a: 'A' }, () => { }).html().replace(/"/g, "'");
+        expect(html).toContain("<div class='radio-container   '><input id='someIdA' type='radio' name='someId' value='A'>");
+        expect(html).toContain("<div class='radio-container   '><input id='someIdB' type='radio' name='someId' value='A'>");
+        expect(html).not.toContain("checked");
+    });
+    it("should click and change value", () => {
+        var remembered = undefined;
+        const component = makeComponent({ a: 'A' }, x => remembered = x);
+        const radios = component.find('.radio-container');
+        expect(radios).toHaveLength(2);
+        radios.at(0).simulate('click');
+        expect(remembered).toEqual({ "a": "a" });
+        radios.at(1).simulate('click');
+        expect(remembered).toEqual({ "a": "b" });
+    });
+});

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

@@ -0,0 +1,13 @@
+import { HasPageSelection } from "@focuson/pages";
+import { HasRestCommands } from "@focuson/rest";
+import { SimpleMessage } from "@focuson/utils";
+import { HasTagHolder } from "@focuson/template";
+interface PageData {
+    a?: string;
+    b?: string;
+}
+export interface RestButtonStateForTest extends HasPageSelection, HasRestCommands, HasTagHolder {
+    messages: SimpleMessage[];
+    mainPage?: PageData;
+}
+export {};

package/dist/src/restButton.spec.js

@@ -0,0 +1,95 @@
+"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 enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+const pages_1 = require("@focuson/pages");
+const rest_1 = require("@focuson/rest");
+const utils_1 = require("@focuson/utils");
+const lens_1 = require("@focuson/lens");
+const form_components_1 = require("@focuson/form_components");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+const emptyS = {
+    messages: [],
+    tags: {},
+    pageSelection: [{ "pageName": "mainPage", "pageMode": "view", time: 'now' }],
+    restCommands: [],
+    mainPage: {}
+};
+let 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: {},
+    dateFn: utils_1.testDateFn,
+    newFetchers: {},
+    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("RestButton", () => {
+    it("should render as a button", () => {
+        const button = displayAndGetButton(emptyS, () => { }, s => (0, jsx_runtime_1.jsx)(form_components_1.RestButton, { rest: 'someRestName', action: 'get', state: s, id: 'someId', name: 'someButtonName' }));
+        expect(button.html()).toEqual('<button aria-errormessage="someId.error" aria-invalid="false" class="button">someButtonName</button>');
+    });
+    it("should place a rest command in the state - simple RestAction", () => {
+        let remembered = undefined;
+        const button = displayAndGetButton(emptyS, s => remembered = s, s => (0, jsx_runtime_1.jsx)(form_components_1.RestButton, { rest: 'someRestName', action: 'get', state: s, id: 'someId' }));
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "mainPage": {},
+            "messages": [],
+            "tags": {},
+            "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now" }],
+            "restCommands": [{ "name": "someRestName", "restAction": "get" }]
+        });
+    });
+    it("should place a rest command in the state - stateChange RestAction", () => {
+        let remembered = undefined;
+        const button = displayAndGetButton(emptyS, s => remembered = s, s => (0, jsx_runtime_1.jsx)(form_components_1.RestButton, { rest: 'someRestName', action: { state: 'newState' }, state: s, id: 'someId' }));
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "mainPage": {},
+            "messages": [],
+            "tags": {},
+            "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now" }],
+            "restCommands": [{ "name": "someRestName", "restAction": { "state": "newState" } }]
+        });
+    });
+    it("should place a rest command in the state - copyOnSuccessAndDeleteOnSuccess", () => {
+        let remembered = undefined;
+        const button = displayAndGetButton(emptyS, s => remembered = s, s => (0, jsx_runtime_1.jsx)(form_components_1.RestButton, { rest: 'someRestName', action: { state: 'newState' }, state: s, id: 'someId', onSuccess: [
+                { command: 'copyResult', from: 'from', to: 'to' },
+                { command: 'delete', path: 'del1' },
+                { command: 'delete', path: 'del2' }
+            ] }));
+        button.simulate('click');
+        expect(remembered).toEqual({
+            "mainPage": {},
+            "tags": {},
+            "messages": [],
+            "pageSelection": [{ "pageMode": "view", "pageName": "mainPage", "time": "now" }],
+            "restCommands": [{
+                    "name": "someRestName",
+                    "restAction": { "state": "newState" },
+                    "changeOnSuccess": [
+                        { "command": "copyResult", "from": "from", "to": "to" },
+                        { "command": "delete", "path": "del1" },
+                        { "command": "delete", "path": "del2" }
+                    ],
+                }]
+        });
+    });
+});

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

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

package/dist/src/selectedItem.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+const enzyme_1 = require("enzyme");
+const form_components_1 = require("@focuson/form_components");
+const state_1 = require("@focuson/state");
+const lens_1 = require("@focuson/lens");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+function displaySelectedItem(s, selectedItemThings, setMain) {
+    function display({ state, mode, id }) {
+        const optJson = state.optJson();
+        return (0, jsx_runtime_1.jsxs)("span", { id: id, children: [mode, "/", optJson] });
+    }
+    const state = (0, state_1.lensState)(s, setMain, 'desc', {});
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.SelectedItem, Object.assign({}, selectedItemThings, { id: 'someId', display: display, state: state.focusOn('data'), allButtons: {} })));
+}
+describe("selectedItem", () => {
+    it("should display the selected item", () => {
+        const x = lens_1.Lenses.identity().focusQuery('data').chain(lens_1.Lenses.nth(1)).getOption({ data: ['1', '2', '3'] });
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view' }, () => { }).html()).toEqual('<span id="someId">view/b</span>');
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 999, mode: 'view' }, () => { }).html()).toEqual('<span id="someId">view/</span>');
+        expect(displaySelectedItem({ data: [] }, { index: 999, mode: 'view' }, () => { }).html()).toEqual('<span id="someId">view/</span>');
+    });
+    it("should display the selected item with a header", () => {
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view', header: 'someTitle' }, () => { }).html()).toEqual('<div><h2>someTitle</h2><span id="someId">view/b</span></div>');
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 999, mode: 'view', header: 'someTitle' }, () => { }).html()).toEqual('<div><h2>someTitle</h2><span id="someId">view/</span></div>');
+        expect(displaySelectedItem({ data: [] }, { index: 999, mode: 'view', header: 'someTitle' }, () => { }).html()).toEqual('<div><h2>someTitle</h2><span id="someId">view/</span></div>');
+    });
+    it("should display the selected item with a  n of m", () => {
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view', showNofM: true }, () => { }).html()).toEqual('<div><h2><span id="someId.nOfM"> 2 / 2</span></h2><span id="someId">view/b</span></div>');
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 999, mode: 'view', showNofM: true }, () => { }).html()).toEqual('<div><h2><span id="someId.nOfM"> 1000 / 2</span></h2><span id="someId">view/</span></div>');
+        expect(displaySelectedItem({ data: [] }, { index: 999, mode: 'view', showNofM: true }, () => { }).html()).toEqual('<div><h2><span id="someId.nOfM"> 1000 / 0</span></h2><span id="someId">view/</span></div>');
+    });
+    it("should display the selected item with a header and n of m", () => {
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view', header: 'someTitle', showNofM: true }, () => { }).html()).toEqual('<div><h2>someTitle<span id="someId.nOfM"> 2 / 2</span></h2><span id="someId">view/b</span></div>');
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 999, mode: 'view', header: 'someTitle', showNofM: true }, () => { }).html()).toEqual('<div><h2>someTitle<span id="someId.nOfM"> 1000 / 2</span></h2><span id="someId">view/</span></div>');
+        expect(displaySelectedItem({ data: [] }, { index: 999, mode: 'view', header: 'someTitle', showNofM: true }, () => { }).html()).toEqual('<div><h2>someTitle<span id="someId.nOfM"> 1000 / 0</span></h2><span id="someId">view/</span></div>');
+    });
+    it("should display the selected item  headerIfEmpty and data empty", () => {
+        expect(displaySelectedItem({ data: [] }, { index: 1, mode: 'view', headerIfEmpty: 'emptyHeader' }, () => { }).html()).toEqual('<div><h2><span id="someId.emptyHeader">emptyHeader</span></h2><span id="someId">view/</span></div>');
+        expect(displaySelectedItem({ data: [] }, { index: 1, mode: 'view', header: 'theHeader', headerIfEmpty: 'emptyHeader' }, () => { }).html()).toEqual('<div><h2>theHeader<span id="someId.emptyHeader">emptyHeader</span></h2><span id="someId">view/</span></div>');
+        expect(displaySelectedItem({ data: [] }, { index: 1, mode: 'view', header: 'theHeader', headerIfEmpty: 'emptyHeader', showNofM: true }, () => { }).html()).toEqual('<div><h2>theHeader<span id="someId.emptyHeader">emptyHeader</span></h2><span id="someId">view/</span></div>');
+    });
+    it("should display the selected item  headerIfEmpty and data not empty", () => {
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view', headerIfEmpty: 'emptyHeader' }, () => { }).html()).toEqual('<div><h2></h2><span id="someId">view/b</span></div>');
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view', header: 'theHeader', headerIfEmpty: 'emptyHeader' }, () => { }).html()).toEqual('<div><h2>theHeader</h2><span id="someId">view/b</span></div>');
+        expect(displaySelectedItem({ data: ['a', 'b'] }, { index: 1, mode: 'view', header: 'theHeader', headerIfEmpty: 'emptyHeader', showNofM: true }, () => { }).html()).toEqual('<div><h2>theHeader<span id="someId.nOfM"> 2 / 2</span></h2><span id="someId">view/b</span></div>');
+    });
+});

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

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