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

package/dist/src/Lens.spec.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//Copyright (c)2020-2022 Philip Rice. <br />Permission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the Software), to dealin the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  <br />The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED AS
+const lens_1 = require("@focuson/lens");
+const LensFixture_1 = require("./LensFixture");
+const utils_1 = require("@focuson/utils");
+describe("Lens", () => {
+    describe("identity", () => {
+        let lens = lens_1.Lenses.identity();
+        it("should return the same", () => {
+            expect(lens.get(LensFixture_1.a1b2ca3)).toBe(LensFixture_1.a1b2ca3);
+        });
+        it("should create the new value", () => {
+            expect(lens.set(LensFixture_1.a1b2ca3, "newValue")).toBe("newValue");
+        });
+        it("should have a description = identity", () => {
+            expect(lens.description).toEqual('I');
+        });
+    });
+    describe("nth", () => {
+        it("should allow access to nth item", () => {
+            expect(lens_1.Lenses.nth(0).getOption(LensFixture_1.list123)).toBe(1);
+            expect(lens_1.Lenses.nth(1).getOption(LensFixture_1.list123)).toBe(2);
+            expect(lens_1.Lenses.nth(2).getOption(LensFixture_1.list123)).toBe(3);
+        });
+        it("should set the nth item", () => {
+            expect(lens_1.Lenses.nth(0).set(LensFixture_1.list123, 4)).toEqual([4, 2, 3]);
+            expect(lens_1.Lenses.nth(1).set(LensFixture_1.list123, 4)).toEqual([1, 4, 3]);
+            expect(lens_1.Lenses.nth(2).set(LensFixture_1.list123, 4)).toEqual([1, 2, 4]);
+        });
+    });
+    describe("lens composition", () => {
+        expect(LensFixture_1.letnstoca.getOption(LensFixture_1.a1b2ca3)).toEqual(3);
+        expect(LensFixture_1.letnstoca.set(LensFixture_1.a1b2ca3, 9)).toEqual({ a: 1, b: 2, c: { a: 9 } });
+        expect(LensFixture_1.letnstoca.transform(old => {
+            expect(old).toEqual(3);
+            return 9;
+        })(LensFixture_1.a1b2ca3)).toEqual({ a: 1, b: 2, c: { a: 9 } });
+        expect(LensFixture_1.letnstoca.description).toEqual('toC.chain(toa)');
+    });
+    describe("'then' should use the field names", () => {
+        let dragonStomachL = lens_1.Lenses.build('dragon').focusOn('body').focusOn('chest').focusOn('stomach');
+        let contentL = dragonStomachL.focusOn('contents');
+        it("allow chained focusOn", () => {
+            expect(dragonStomachL.get(LensFixture_1.dragon)).toEqual(({ contents: ['the adventurer'] }));
+            expect(contentL.transform(old => [...old, 'moreGoodness'])(LensFixture_1.dragon)).toEqual(LensFixture_1.dragon2);
+            //and nothing should have changed
+            expect(dragonStomachL.get(LensFixture_1.dragon)).toEqual(({ contents: ['the adventurer'] }));
+        });
+        it('should have a nice description', () => {
+            expect(dragonStomachL.description).toEqual("dragon.focusOn(body).focusOn(chest).focusOn(stomach)");
+        });
+    });
+    describe("lens.last", () => {
+        let abc = ['a', 'b', 'c'];
+        it("should access the last item", () => {
+            expect(lens_1.Lenses.last().getOption(abc)).toEqual('c');
+            expect(lens_1.Lenses.last().setOption(abc, 'd')).toEqual(['a', 'b', 'd']);
+        });
+    });
+    describe("lens.append", () => {
+        let abc = ['a', 'b', 'c'];
+        it("should access the last item", () => {
+            expect(lens_1.Lenses.append().getOption(abc)).toEqual(undefined);
+            expect(lens_1.Lenses.append().setOption(abc, 'd')).toEqual(['a', 'b', 'c', 'd']);
+        });
+    });
+    describe("lens.nth", () => {
+        let abc = ['a', 'b', 'c'];
+        it("should throw exception with negative length", () => {
+            expect(() => lens_1.Lenses.nth(-1)).toThrow('Cannot give Lens.nth a negative n [-1]');
+        });
+        it("should have a description", () => {
+            expect(lens_1.Lenses.nth(0).description).toEqual('[0]');
+            expect(lens_1.Lenses.nth(5).description).toEqual('[5]');
+        });
+        describe("getOption", () => {
+            it("should  getOption", () => {
+                expect(lens_1.Lenses.nth(0).getOption(abc)).toEqual('a');
+                expect(lens_1.Lenses.nth(1).getOption(abc)).toEqual('b');
+                expect(lens_1.Lenses.nth(2).getOption(abc)).toEqual('c');
+            });
+            it("should  return undefined if out of range", () => {
+                expect(lens_1.Lenses.nth(4).getOption(abc)).toEqual(undefined);
+            });
+        });
+        describe("set", () => {
+            it("should create new with data inserted", () => {
+                expect(lens_1.Lenses.nth(1).set(abc, 'd')).toEqual(["a", "d", "c"]);
+                expect(abc).toEqual(['a', 'b', 'c']);
+            });
+            it("should set if n is too big", () => {
+                expect(lens_1.Lenses.nth(4).set(abc, 'd')).toEqual(["a", "b", "c", undefined, "d"]);
+            });
+        });
+    });
+    describe("map", () => {
+        it("should pass existing value to a fn and use the result", () => {
+            expect(LensFixture_1.letnstoca.map(LensFixture_1.a1b2ca3, old => old + 1)).toEqual({ "a": 1, "b": 2, "c": { "a": 4 } });
+        });
+        it("should work even if the original was undefined", () => {
+            expect(LensFixture_1.letnstoca.map(Object.assign(Object.assign({}, LensFixture_1.a1b2ca3), { c: undefined }), old => 4)).toEqual({ "a": 1, "b": 2, "c": { "a": 4 } });
+        });
+    });
+    describe("lookUp", () => {
+        it("should make a lens that maps from id to value, when id and value are object of {[name: string]: value}", () => {
+            const state = {
+                lookup: { 'one': 1, 'two': 2 },
+                date: 'one'
+            };
+            const dataL = lens_1.Lenses.identity().focusQuery('date');
+            const lookupL = lens_1.Lenses.identity().focusQuery('lookup');
+            const l = lens_1.Lenses.chainLookup(dataL, lookupL);
+            expect(l.getOption(state)).toEqual(1);
+            expect(l.setOption(state, 2)).toEqual({ lookup: { 'one': 1, 'two': 2 }, date: 'two' });
+        });
+    });
+    describe("lookUpTable", () => {
+        it("should make a lens that maps from id to value, when id and value are object of {[name: string]: value}", () => {
+            const state = {
+                lookup: [{ id: 'one', value: 1 }, { id: 'two', value: 2 }],
+                date: 'one'
+            };
+            const dataL = lens_1.Lenses.identity().focusQuery('date');
+            const lookupL = lens_1.Lenses.identity().focusQuery('lookup');
+            const l = lens_1.Lenses.chainLookupTable(dataL, lookupL, 'id', 'value');
+            expect(l.getOption(state)).toEqual(1);
+            expect(l.setOption(state, 2)).toEqual({ lookup: [{ id: 'one', value: 1 }, { id: 'two', value: 2 }], date: 'two' });
+        });
+    });
+    describe("trasnformTwoValues", () => {
+        let start = { item1: "one", selected: { item2: "two" } };
+        let lens1 = (0, lens_1.identityOptics)().focusQuery('item1');
+        let lens2 = (0, lens_1.identityOptics)().focusQuery('selected').focusQuery('item2');
+        const add = (infix) => (a, b) => a + infix + b;
+        let tx = (0, lens_1.transformTwoValues)(lens1, lens2)(add("+"), add("-"));
+        it("should transform when both can be set", () => {
+            expect(tx({ item1: "one", selected: { item2: "two2" } })).toEqual({ "item1": "one+two2", "selected": { "item2": "one-two2" } });
+        });
+    });
+});
+describe("lens utils", () => {
+    it("should have a arrays equal that returns true if the two parameters are both defined and equal", () => {
+        expect((0, utils_1.arraysEqual)(undefined, undefined)).toEqual(false);
+        expect((0, utils_1.arraysEqual)([], undefined)).toEqual(false);
+        expect((0, utils_1.arraysEqual)(["a"], undefined)).toEqual(false);
+        expect((0, utils_1.arraysEqual)(undefined, undefined)).toEqual(false);
+        expect((0, utils_1.arraysEqual)(undefined, [])).toEqual(false);
+        expect((0, utils_1.arraysEqual)(undefined, ["a"])).toEqual(false);
+        expect((0, utils_1.arraysEqual)([], ["a"])).toEqual(false);
+        expect((0, utils_1.arraysEqual)(["b"], ["a"])).toEqual(false);
+        expect((0, utils_1.arraysEqual)(["b"], [])).toEqual(false);
+        expect((0, utils_1.arraysEqual)([], [])).toEqual(true);
+        expect((0, utils_1.arraysEqual)(["a"], ["a"])).toEqual(true);
+        expect((0, utils_1.arraysEqual)(["a", "b"], ["a", "b"])).toEqual(true);
+    });
+    it("should have a areAllDefined that returns true only if the array and its contents are all defined", () => {
+        expect((0, utils_1.areAllDefined)(undefined)).toEqual(false);
+        expect((0, utils_1.areAllDefined)([undefined])).toEqual(false);
+        expect((0, utils_1.areAllDefined)([undefined, "a"])).toEqual(false);
+        expect((0, utils_1.areAllDefined)(["b", undefined, "a"])).toEqual(false);
+        expect((0, utils_1.areAllDefined)(["b", "a"])).toEqual(true);
+    });
+});

package/dist/src/LensFixture.d.ts

@@ -0,0 +1,28 @@
+export declare let a1b2ca3: {
+    a: number;
+    b: number;
+    c: {
+        a: number;
+    };
+};
+export declare let list123: number[];
+export declare let lensToc: import("@focuson/lens").Lens<any, any>;
+export declare let lenscToa: import("@focuson/lens").Optional<any, any>;
+export declare let letnstoca: import("@focuson/lens").Optional<any, any>;
+export declare let dragon: Dragon;
+export declare let dragon2: Dragon;
+export interface Dragon {
+    body: Body;
+}
+export interface Body {
+    chest: Chest;
+}
+export interface Chest {
+    stomach: Stomach;
+    heart?: string;
+}
+export interface Stomach {
+    contents: any[];
+}
+export declare class DragonDomain {
+}

package/dist/src/LensFixture.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonDomain = exports.dragon2 = exports.dragon = exports.letnstoca = exports.lenscToa = exports.lensToc = exports.list123 = exports.a1b2ca3 = void 0;
+//Copyright (c)2020-2022 Philip Rice. <br />Permission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the Software), to dealin the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  <br />The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED AS
+const lens_1 = require("@focuson/lens");
+exports.a1b2ca3 = { a: 1, b: 2, c: { a: 3 } };
+exports.list123 = [1, 2, 3];
+exports.lensToc = (0, lens_1.lens)(f => f.c, (m, c) => (Object.assign(Object.assign({}, m), { c })), 'toC');
+exports.lenscToa = (0, lens_1.optional)(f => f.a, (m, a) => (Object.assign(Object.assign({}, m), { a })), 'toa');
+exports.letnstoca = exports.lensToc.chain(exports.lenscToa);
+exports.dragon = { body: { chest: { stomach: { contents: ["the adventurer"] } } } };
+exports.dragon2 = { body: { chest: { stomach: { contents: ["the adventurer", "moreGoodness"] } } } };
+class DragonDomain {
+}
+exports.DragonDomain = DragonDomain;

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

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

package/dist/src/LensState.spec.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//Copyright (c)2020-2022 Philip Rice. <br />Permission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the Software), to dealin the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  <br />The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED AS
+const lens_1 = require("@focuson/lens");
+const state_1 = require("@focuson/state");
+const LensFixture_1 = require("./LensFixture");
+let initialMain = Object.assign({}, LensFixture_1.dragon);
+let setMain = jest.fn();
+const context = 'context';
+let dragonLS = (0, state_1.lensState)(LensFixture_1.dragon, setMain, "dragon", context);
+let chestLS = dragonLS.focusOn('body').focusOn('chest');
+let stomachLS = chestLS.focusOn('stomach');
+function setupForSetMain(state, fn) {
+    const setMain = jest.fn();
+    let newContext = new state_1.LensState(state.main, setMain, state.optional, context);
+    fn(newContext, setMain);
+}
+function checkSetMainWas(setMain, expected) {
+    expect(setMain.mock.calls.length).toEqual(1);
+    expect(setMain.mock.calls[0][0]).toEqual(expected);
+    expect(LensFixture_1.dragon).toEqual(initialMain); //just checking no sideeffects
+}
+function checkLensState(ls, lensDescription) {
+    expect(ls.main).toEqual(LensFixture_1.dragon);
+    expect(ls.optional.description).toEqual(lensDescription);
+    expect(ls.dangerouslySetMain).toEqual(setMain);
+}
+describe("LensState", () => {
+    it("create", () => {
+        checkLensState(dragonLS, 'dragon');
+        checkLensState(chestLS, 'dragon.focus?(body).focus?(chest)');
+    });
+    it("should have json equal to the focus of the  lens", () => {
+        expect(dragonLS.json()).toEqual(LensFixture_1.dragon);
+        expect(chestLS.json()).toEqual(LensFixture_1.dragon.body.chest);
+    });
+    it("should have a setJson that creates even when parent isn't there", () => {
+        // @ts-ignore
+        const empty = {};
+        var remembered = {};
+        let dragonLS = (0, state_1.lensState)(empty, d => remembered = d, "dragon", context);
+        let ls = dragonLS.focusOn('body').focusOn('chest').focusOn('stomach').focusOn('contents');
+        ls.setJson([1, 2, 3], 'someReason');
+        expect(remembered).toEqual({ "body": { "chest": { "stomach": { "contents": [1, 2, 3] } } } });
+    });
+    it("with Lens should ignore the parent lens", () => {
+        let replace = chestLS.copyWithLens(chestLS.optional.withDescription('theNewLens'));
+        checkLensState(replace, 'theNewLens');
+    });
+    it("with withChildLens should concatenate with the parent lens", () => {
+        let child = chestLS.chainLens(lens_1.Lenses.identity().withDescription('childName'));
+        checkLensState(child, 'dragon.focus?(body).focus?(chest).chain(childName)');
+    });
+    it("setJson should call danagerouslySetMain with the result of passing main and the new json to the lens", () => {
+        let json = { contents: [1, 2, 3] };
+        setupForSetMain(stomachLS, (context, setMain) => {
+            context.setJson(json, 'someReason');
+            checkSetMainWas(setMain, stomachLS.optional.set(LensFixture_1.dragon, json));
+        });
+    });
+    // it("setFrom should call dangerousSetMain using the lens concatenated to the current state", () => {
+    //     let json = {stomach: {contents: [1, 2, 3]}};
+    //     setupForSetMain(stomachLS, (context, setMain) => {
+    //         let newLens = Lens.build<Dragon>('passedLens')
+    //         context.setFrom(newLens, json)
+    //         checkSetMainWas(setMain, context.optional.andThen(square3L).set(SimpleGameDomain.emptyGame, 'X'))
+    //     })
+    // })
+});
+describe("lenState2", () => {
+    it("should update two lens simultaneously", () => {
+        setupForSetMain(dragonLS, (ls, setMain) => {
+            const ls2 = ls.focusOn('body').focusOn('chest').doubleUp().focus1On('stomach').focus2On('heart');
+            ls2.setJson({ contents: ['some'] }, 'thing', 'someReason');
+            checkSetMainWas(setMain, {
+                "body": {
+                    "chest": {
+                        "heart": "thing",
+                        "stomach": { "contents": ["some"] }
+                    }
+                }
+            });
+        });
+    });
+    it("should allow 'chainWithLens1 chainWithLens2", () => {
+        setupForSetMain(dragonLS, (ls, setMain) => {
+            const identity = lens_1.Lenses.identity('id');
+            const ls2 = ls.focusOn('body').focusOn('chest').doubleUp();
+            ls2.chain1(identity.focusOn('stomach')).chain2(identity.focusOn('heart')).setJson({ contents: ['some'] }, 'thing', 'reason');
+            checkSetMainWas(setMain, {
+                "body": {
+                    "chest": {
+                        "heart": "thing",
+                        "stomach": { "contents": ["some"] }
+                    }
+                }
+            });
+        });
+    });
+});

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

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

package/dist/src/MonthYearDataPickerWithLength.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@focuson/utils");
+describe("addDate", () => {
+    it("should return the original date if we have funny values", () => {
+        expect((0, utils_1.addDate)(false, undefined, 10, false)).toEqual(undefined);
+        expect((0, utils_1.addDate)(false, '', 10, false)).toEqual('');
+        expect((0, utils_1.addDate)(false, 'xx', 10, false)).toEqual('xx');
+        expect((0, utils_1.addDate)(false, '12', 10, false)).toEqual('12');
+    });
+    it('should add months with /', () => {
+        expect((0, utils_1.addDate)(false, '01/2012', 10, false)).toEqual('11/2012');
+        expect((0, utils_1.addDate)(false, '1/2012', 10, false)).toEqual('11/2012');
+        expect((0, utils_1.addDate)(false, '12/2012', 10, false)).toEqual('10/2013');
+    });
+    it('should add months with -', () => {
+        expect((0, utils_1.addDate)(false, '01-2012', 10, false)).toEqual('11/2012');
+        expect((0, utils_1.addDate)(false, '1-2012', 10, false)).toEqual('11/2012');
+        expect((0, utils_1.addDate)(false, '12-2012', 10, false)).toEqual('10/2013');
+    });
+});

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

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

package/dist/src/WithTextLayout.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const enzymeAdapterSetup_1 = require("./enzymeAdapterSetup");
+const form_components_1 = require("@focuson/form_components");
+const enzyme_1 = require("enzyme");
+const state_1 = require("@focuson/state");
+const context_fixture_1 = require("./context.fixture");
+(0, enzymeAdapterSetup_1.enzymeSetup)();
+const empty = {
+    messages: [], pageSelection: [], restCommands: [], tags: {}
+};
+// text: string;
+//   holderClassName?: string
+//   textClassName?: string
+//   childrenClassName?: string
+function withText(text, holderClassName, textClassName, childrenClassName) {
+    const state = (0, state_1.lensState)(empty, () => { }, '', (0, context_fixture_1.context)());
+    return (0, enzyme_1.mount)((0, jsx_runtime_1.jsx)(form_components_1.WithTextLayout, { text: text, state: state.focusOn('data'), textClassName: textClassName, holderClassName: holderClassName, childrenClassName: childrenClassName, children: (0, jsx_runtime_1.jsx)("p", { children: "Children" }) })).html();
+}
+describe("WithTextLayout", () => {
+    it('should render ', () => {
+        expect(withText('someText', undefined, undefined, undefined)).toEqual('<div><div>someText</div><div><p>Children</p></div></div>');
+        expect(withText('someText', 'holder', 'text', 'children')).toEqual('<div class="holder"><div class="text">someText</div><div class="children"><p>Children</p></div></div>');
+    });
+    it("should render html", () => {
+        expect(withText('someText <b>That is bold</b>', undefined, undefined, undefined)).toEqual('<div><div>someText <b>That is bold</b></div><div><p>Children</p></div></div>');
+    });
+});

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

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

package/dist/src/actions.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const state_1 = require("@focuson/state");
+const actions_1 = require("@focuson/forms/src/actions");
+const lens_1 = require("@focuson/lens");
+const pending = { status: 'PENDING', type: 'CR', amount: '1.00' };
+const pendingHeld = { status: 'PENDING', hold: true, type: 'CR', amount: '1.00' };
+const approved = { status: 'APPROVED', type: 'CR', amount: '1.00' };
+const approvedHeld = { status: 'APPROVED', hold: true, type: 'CR', amount: '1.00' };
+const authorised = { status: 'AUTHORISED', type: 'CR', amount: '1.00' };
+const authorisedHeld = { status: 'AUTHORISED', hold: true, type: 'CR', amount: '1.00' };
+const state = (setMain) => (...data) => (0, state_1.lensState)({ data, CommonIds: { operatorName: 'Phil' } }, setMain, '', {}).focusOn('data');
+describe("actions", () => {
+    it("approvePending should update pendings if they are not held", () => {
+        var remembered = {};
+        const start = state(m => remembered = m)(pending, pending, pendingHeld, pendingHeld, approved, approvedHeld, authorised, authorisedHeld);
+        expect((0, lens_1.displayTransformsInState)(start.main, (0, actions_1.approvePendingFees)(start, 'someId'))).toEqual([
+            {
+                "opt": ".focus?(data).chain([0])",
+                "value": { "amount": "1.00", "approvedBy": "Phil", "status": "APPROVED", "type": "CR" }
+            },
+            {
+                "opt": ".focus?(data).chain([1])",
+                "value": { "amount": "1.00", "approvedBy": "Phil", "status": "APPROVED", "type": "CR" }
+            }
+        ]);
+        expect(remembered).toEqual({});
+    });
+    it("authoriseApprovedFees should update approved if they are not held", () => {
+        var remembered = {};
+        const start = state(m => remembered = m)(pending, pending, pendingHeld, pendingHeld, approved, approvedHeld, authorised, authorisedHeld);
+        expect((0, lens_1.displayTransformsInState)(start.main, (0, actions_1.authoriseApprovedFees)(start, 'someId'))).toEqual([
+            {
+                "opt": ".focus?(data).chain([4])",
+                "value": { "amount": "1.00", "authorisedBy": "Phil", "status": "AUTHORISED", "type": "CR" }
+            }
+        ]);
+        expect(remembered).toEqual({});
+    });
+});

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

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

package/dist/src/composition.spec.js

@@ -0,0 +1,28 @@
+"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 utils_1 = require("@focuson/utils");
+describe("error monad", () => {
+    it("call the functions in order", () => {
+        expect((0, utils_1.errorMonad)("start", false, (s, e) => "failed", ['one', s => s + ".1"], ['two', s => s + ".2"], ['three', s => s + ".3"])).toEqual('start.1.2.3');
+    });
+    it("stop calling functions after an error occurs, return the results of the error handler", () => {
+        expect((0, utils_1.errorMonad)("start", false, (s, e) => s + "/" + e + "/failed", ['one', s => s + ".1"], ['two', s => { throw Error('someError'); }], ['three', s => s + ".3"])).toEqual('start.1/Error: someError/failed');
+    });
+});
+describe("error promise monad", () => {
+    it("call the functions in order", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield (0, utils_1.errorPromiseMonad)((s, e) => "failed")("start", false, ['one', s => Promise.resolve(s + ".1")], ['two', s => Promise.resolve(s + ".2")], ['three', s => Promise.resolve(s + ".3")])).toEqual('start.1.2.3');
+    }));
+    it("stop calling functions after an error occurs, return the results of the error handler", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield (0, utils_1.errorPromiseMonad)((s, e) => s + "/" + e + "/failed")("start", false, ['one', s => Promise.resolve(s + ".1")], ['two', s => { throw Error('someError'); }], ['three', s => Promise.resolve(s + ".3")])).toEqual('start.1/Error: someError/failed');
+    }));
+});

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

@@ -0,0 +1,6 @@
+import { HasRestCommands } from "@focuson/rest";
+import { HasPageSelection } from "@focuson/pages";
+import { FocusOnContext } from "@focuson/focuson";
+import { HasSimpleMessages } from "@focuson/utils";
+import { HasTagHolder } from "@focuson/template";
+export declare function context<S extends HasRestCommands & HasPageSelection & HasSimpleMessages & HasTagHolder>(mockJwt?: boolean): FocusOnContext<S>;

package/dist/src/context.fixture.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = context;
+const focuson_1 = require("@focuson/focuson");
+const utils_1 = require("@focuson/utils");
+const form_components_1 = require("@focuson/form_components");
+function context(mockJwt) {
+    return Object.assign(Object.assign({}, (0, focuson_1.defaultPageSelectionAndRestCommandsContext)({}, {}, {}, {}, utils_1.testDateFn, mockJwt !== false)), { combine: form_components_1.MyCombined });
+}

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

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