@luomus/laji-form 15.0.0 → 15.1.1

package/test-export/validation-spec.js

@@ -0,0 +1,336 @@
+"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 test_utils_1 = require("./test-utils");
+const properties = require("../properties.json");
+describe("Validations", () => {
+    let form;
+    // Uncomment when https://github.com/rjsf-team/react-jsonschema-form/pull/1528 is merged.
+    //beforeAll(async () => {
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        form = yield test_utils_1.createForm();
+    }));
+    const schema = {
+        type: "object",
+        properties: {
+            a: {
+                type: "string"
+            },
+            b: {
+                type: "string"
+            }
+        },
+    };
+    const formData = { b: "bar" };
+    const message = "foo";
+    const getCustom = (message = "foo", live) => ({
+        a: {
+            presence: {
+                message,
+                options: {
+                    _live: live
+                }
+            }
+        }
+    });
+    it("pass on no errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield form.setState({ schema, formData });
+        yield form.submit();
+        expect(yield form.getSubmittedData()).toEqual(formData);
+    }));
+    it("fail on schema errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield form.setState({ schema: Object.assign(Object.assign({}, schema), { required: ["a"] }), formData });
+        yield form.submit();
+        expect(yield form.getSubmittedData()).not.toEqual(formData);
+        expect(yield form.errors.$$all.count()).toBe(1);
+    }));
+    it("doesn't run schema validators before submitted", () => __awaiter(void 0, void 0, void 0, function* () {
+        const _formData = Object.assign(Object.assign({}, formData), { a: "foo" });
+        yield form.setState({ schema: Object.assign(Object.assign({}, schema), { required: ["a"] }), formData: _formData });
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield form.submit();
+        expect(yield form.errors.$$all.count()).toBe(1);
+    }));
+    it("fail on custom errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = getCustom();
+        const formData = {};
+        yield form.setState({ schema, formData, validators });
+        yield form.submit();
+        expect(yield form.getSubmittedData()).not.toEqual(formData);
+        expect(yield form.errors.$$all.get(0).getText()).toContain(message);
+    }));
+    describe("warnings", () => {
+        it("prevent submit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const warnings = getCustom();
+            yield form.setState({ schema, formData, warnings });
+            yield form.submit();
+            expect(yield form.getSubmittedData()).not.toEqual(formData);
+            expect(yield form.warnings.$$all.get(0).getText()).toContain(message);
+        }));
+        it("can be submitted via warnings-acknowledged-submit button", () => __awaiter(void 0, void 0, void 0, function* () {
+            const warnings = getCustom();
+            yield form.setState({ schema, formData, warnings });
+            yield form.submit();
+            yield test_utils_1.waitUntilBlockingLoaderHides();
+            yield form.$acknowledgeWarnings.click();
+            expect(yield form.getSubmittedData()).toEqual(formData);
+        }));
+    });
+    [["errors", "validators"], ["warnings", "warnings"]].forEach(([type, propName]) => {
+        it(`doesn't run ${type} live validators on init`, () => __awaiter(void 0, void 0, void 0, function* () {
+            const validators = getCustom(message, "live");
+            const formData = {};
+            yield form.setState({ schema, formData, [propName]: validators });
+            expect(yield form[type].$panel.isPresent()).toBe(false);
+        }));
+        it(`runs live ${type} validators on onChange`, () => __awaiter(void 0, void 0, void 0, function* () {
+            const validators = getCustom(message, "live");
+            const formData = { a: "bar" };
+            yield form.setState({ schema, formData, [propName]: validators });
+            yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+            expect(yield form[type].$$all.get(0).getText()).toContain(message);
+        }));
+    });
+    it("doesn't show blocker during live validation", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = getCustom(message, "live");
+        const formData = { a: "bar" };
+        yield form.setState({ schema, formData, validators });
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        expect(yield form.isBlocked()).toBe(false);
+    }));
+    it("runs both validators and warnings live on Change", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = getCustom(message, "live");
+        const formData = { a: "bar" };
+        yield form.setState({ schema, formData, validators, warnings: validators });
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        for (const type of ["errors", "warnings"]) {
+            expect(yield form[type].$$all.get(0).getText()).toContain(message);
+        }
+    }));
+    it("keeps non live errors when doing only live validation", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = getCustom(message, "live");
+        const warnings = getCustom(message);
+        const formData = { a: "bar" };
+        yield form.setState({ schema, formData, validators, warnings });
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        yield form.submit();
+        yield test_utils_1.waitUntilBlockingLoaderHides();
+        expect(yield form.warnings.$$all.get(0).getText()).toContain(message);
+        expect(yield form.errors.$$all.get(0).getText()).toContain(message);
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "bar");
+        expect(yield form.warnings.$$all.get(0).getText()).toContain(message);
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        for (const type of ["errors", "warnings"]) {
+            expect(yield form[type].$$all.get(0).getText()).toContain(message);
+        }
+    }));
+    it("cached non live errors are cleared when validated again against valid", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = getCustom(message, "live");
+        const warnings = getCustom(message);
+        const formData = { a: "bar" };
+        yield form.setState({ schema, formData, validators, warnings });
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        yield form.submit();
+        yield test_utils_1.waitUntilBlockingLoaderHides();
+        expect(yield form.warnings.$$all.get(0).getText()).toContain(message);
+        expect(yield form.errors.$$all.get(0).getText()).toContain(message);
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "bar");
+        expect(yield form.warnings.$$all.get(0).getText()).toContain(message);
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "");
+        yield test_utils_1.updateValue(form.$getInputWidget("a"), "bar");
+        yield form.submit();
+        for (const type of ["errors", "warnings"]) {
+            expect(yield form[type].$$all.count()).toBe(0);
+        }
+    }));
+    it("runs all validator types on submit", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = getCustom(message, "live");
+        const _validators = Object.assign(Object.assign({}, validators), { b: validators.a });
+        const warnings = Object.assign(Object.assign({}, validators), { b: validators.a });
+        yield form.setState({ schema, formData, validators: _validators, warnings });
+        yield test_utils_1.updateValue(form.$getInputWidget("b"), "");
+        yield form.submit();
+        expect(yield form.getSubmittedData()).not.toEqual(formData);
+        expect(yield form.errors.$$all.count()).toBe(2);
+        expect(yield form.warnings.$$all.count()).toBe(2);
+    }));
+    const response = {
+        "error": {
+            "statusCode": 422,
+            "name": "Error",
+            "message": "Unprocessable Entity",
+            "details": {
+                ".a": [
+                    "mock"
+                ]
+            }
+        }
+    };
+    it("delays submit until async validators complete and doesn't submit when invalid", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = {
+            a: {
+                remote: {
+                    validator: "mock",
+                    message
+                }
+            }
+        };
+        const { resolve, remove } = yield form.setMockResponse("/documents/validate", false);
+        const _formData = Object.assign(Object.assign({}, formData), { a: "empty isn't async validated so we have value here" });
+        yield form.setState({ schema, formData: _formData, validators });
+        yield form.startSubmit();
+        expect(yield form.getSubmittedData()).not.toEqual(_formData);
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield resolve({ status: 422, json: response }, !!"raw");
+        expect(yield form.errors.$$all.count()).toBe(1);
+        expect(yield form.errors.$$all.get(0).getText()).toContain(message);
+        yield remove();
+    }));
+    it("delays submit until async validators complete and submits when valid", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = {
+            a: {
+                remote: {
+                    validator: "mock",
+                    message
+                }
+            }
+        };
+        const { resolve, remove } = yield form.setMockResponse("/documents/validate", false);
+        const _formData = Object.assign(Object.assign({}, formData), { a: "empty isn't async validated so we have value here" });
+        yield form.setState({ schema, formData: _formData, validators });
+        yield form.startSubmit();
+        expect(yield form.getSubmittedData()).not.toEqual(_formData);
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield resolve({});
+        expect(yield form.getSubmittedData()).toEqual(_formData);
+        yield remove();
+    }));
+    it("delays all validators until async operations complete", () => __awaiter(void 0, void 0, void 0, function* () {
+        const validators = {
+            a: {
+                remote: {
+                    validator: "mock",
+                    message
+                }
+            }
+        };
+        const { resolve, remove } = yield form.setMockResponse("/documents/validate", false);
+        const _formData = Object.assign(Object.assign({}, formData), { a: "empty isn't async validated so we have value here" });
+        yield form.setState({ schema, formData: _formData, validators });
+        yield form.startSubmit();
+        expect(yield form.getSubmittedData()).not.toEqual(_formData);
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield resolve({ status: 422, json: response }, !!"raw");
+        expect(yield form.errors.$$all.count()).toBe(1);
+        expect(yield form.errors.$$all.get(0).getText()).toContain(message);
+        yield remove();
+    }));
+    const uiSchema = {
+        c: {
+            "ui:field": "ImageArrayField"
+        }
+    };
+    const uiSchemaContext = {
+        creator: properties.userId
+    };
+    const schemaForAsync = Object.assign(Object.assign({}, schema), { properties: Object.assign(Object.assign({}, schema.properties), { c: {
+                type: "array",
+                items: {
+                    type: "string"
+                }
+            } }) });
+    const imageUploaded = "imgae uploaded";
+    const asyncValidators = {
+        b: {
+            remote: {
+                validator: "mock",
+                message
+            },
+            presence: {
+                message,
+                options: {
+                    _live: true
+                }
+            }
+        },
+        c: {
+            length: {
+                maximum: 0,
+                message: imageUploaded
+            }
+        }
+    };
+    it("validations aren't run when async validation running already", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { resolve, remove } = yield form.setMockResponse("/documents/validate", false);
+        yield form.setState({ schema: schemaForAsync, formData, validators: asyncValidators, uiSchema, uiSchemaContext });
+        const { resolve: imageResolve, remove: imageRemove } = yield form.mockImageUpload("c");
+        yield form.startSubmit();
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield imageResolve();
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield resolve({});
+        yield remove();
+        yield imageRemove();
+    }));
+    it("revalidates when data is edited during async validation on submit", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { resolve, remove } = yield form.setMockResponse("/documents/validate", false);
+        yield form.setState({ schema: schemaForAsync, formData, validators: asyncValidators, uiSchema, uiSchemaContext });
+        const { resolve: imageResolve, remove: imageRemove } = yield form.mockImageUpload("c");
+        yield form.startSubmit();
+        expect(yield form.errors.$$all.count()).toBe(0);
+        yield imageResolve();
+        yield resolve({});
+        yield test_utils_1.waitUntilBlockingLoaderHides();
+        expect(yield form.errors.$$all.count()).toBe(1);
+        expect(yield form.errors.$$all.get(0).getText()).toContain(imageUploaded);
+        yield remove();
+        yield imageRemove();
+    }));
+    it("shows blocking loader when validating", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { resolve, remove } = yield form.setMockResponse("/documents/validate", false);
+        yield form.setState({ schema, formData, validators: asyncValidators });
+        expect(yield form.isBlocked()).toBe(false);
+        yield form.startSubmit();
+        expect(yield form.isBlocked()).toBe(true);
+        yield resolve({ status: 422, json: response }, !!"raw");
+        yield test_utils_1.waitUntilBlockingLoaderHides();
+        expect(yield form.isBlocked()).toBe(false);
+        yield remove();
+    }));
+    describe("Custom validation bypass", () => {
+        it("skips custom errors and warnings", () => __awaiter(void 0, void 0, void 0, function* () {
+            const validators = getCustom(message);
+            yield form.setState({ schema, formData, validators, warnings: validators });
+            yield form.submitOnlySchemaValidations();
+            yield form.waitUntilBlockingLoaderHides();
+            expect(yield form.errors.$$all.count()).toBe(0);
+            expect(yield form.warnings.$$all.count()).toBe(0);
+        }));
+        it("skips live errors and live warnings", () => __awaiter(void 0, void 0, void 0, function* () {
+            const validators = getCustom(message, "live");
+            yield form.setState({ schema, formData, validators, warnings: validators });
+            yield form.submitOnlySchemaValidations();
+            yield form.waitUntilBlockingLoaderHides();
+            expect(yield form.errors.$$all.count()).toBe(0);
+            expect(yield form.warnings.$$all.count()).toBe(0);
+        }));
+        it("runs schema validations", () => __awaiter(void 0, void 0, void 0, function* () {
+            form = yield test_utils_1.createForm();
+            yield form.setState({ schema: Object.assign(Object.assign({}, schema), { required: ["a"] }), formData });
+            yield form.submitOnlySchemaValidations();
+            yield form.waitUntilBlockingLoaderHides();
+            expect(yield form.errors.$$all.count()).toBe(1);
+        }));
+    });
+});

package/test-export/water-bird-spec.d.ts

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

package/test-export/water-bird-spec.js

@@ -0,0 +1,30 @@
+"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 test_utils_1 = require("./test-utils");
+const protractor_1 = require("protractor");
+describe("water bird pair count form (MHL.65)", () => {
+    let form;
+    beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        form = yield test_utils_1.createForm({ id: "MHL.65", localFormData: true });
+    }));
+    it("sets correct unitType to pair observations when using add button", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield form.$locateButton("gatherings_0_units", "add").click();
+        const formData = yield form.getChangedData();
+        expect(formData.gatherings[0].units[0].unitType[0]).toBe("pairObservation");
+    }));
+    it("sets correct unitType to pair observations when using insert shorthand", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield form.$locateButton("gatherings_0_units", "add").click();
+        yield protractor_1.browser.driver.switchTo().activeElement().sendKeys(protractor_1.protractor.Key.chord(protractor_1.protractor.Key.ALT, "i"));
+        const formData = yield form.getChangedData();
+        expect(formData.gatherings[0].units[1].unitType[0]).toBe("pairObservation");
+    }));
+});

package/test-export/wbc-spec.d.ts

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

package/test-export/wbc-spec.js

@@ -0,0 +1,82 @@
+"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 test_utils_1 = require("./test-utils");
+const protractor_1 = require("protractor");
+describe("WBC (MHL.3)", () => {
+    let form;
+    it("navigate to form", () => __awaiter(void 0, void 0, void 0, function* () {
+        form = yield test_utils_1.createForm({ id: "MHL.3", localFormData: true, isAdmin: true });
+    }));
+    it("taxon census has aves", () => __awaiter(void 0, void 0, void 0, function* () {
+        const formData = yield form.getPropsData();
+        expect(formData.gatherings[0].taxonCensus[0].censusTaxonID).toBe("MX.37580");
+    }));
+    it("taxon census has correct values when yes is selected", () => __awaiter(void 0, void 0, void 0, function* () {
+        const widget = form.getBooleanWidget("gatherings.0.taxonCensus");
+        yield widget.$true.click();
+        const formData = yield form.getChangedData();
+        expect(formData.gatherings[0].taxonCensus.length).toBe(2);
+        expect(formData.gatherings[0].taxonCensus[0].censusTaxonID).toBe("MX.37580");
+        expect(formData.gatherings[0].taxonCensus[1].censusTaxonID).toBe("MX.37612");
+    }));
+    it("taxon census has correct values when no is selected", () => __awaiter(void 0, void 0, void 0, function* () {
+        const widget = form.getBooleanWidget("gatherings.0.taxonCensus");
+        yield widget.$false.click();
+        const formData = yield form.getChangedData();
+        expect(formData.gatherings[0].taxonCensus.length).toBe(1);
+        expect(formData.gatherings[0].taxonCensus[0].censusTaxonID).toBe("MX.37580");
+    }));
+    it("added existing user is shown as suggested", () => __awaiter(void 0, void 0, void 0, function* () {
+        // ID for button is broken, should be gatheringEvent.leg?
+        yield form.$locateButton("gatheringEvent", "add").click();
+        const $field = form.$locate("gatheringEvent.1.leg");
+        const $input = form.$getInputWidget("gatheringEvent.1.leg");
+        yield $input.sendKeys("unit");
+        const $suggestionList = $field.$(".rw-list");
+        const $$suggestions = $field.$$(".rw-list-option");
+        yield protractor_1.browser.wait(protractor_1.protractor.ExpectedConditions.visibilityOf($suggestionList), 5000, "Suggestion list timeout");
+        yield $$suggestions.first().click();
+        yield protractor_1.browser.wait(protractor_1.protractor.ExpectedConditions.invisibilityOf($field.$(".react-spinner")), 5000, "Field input spinner didn't leave");
+        expect(yield form.$locate("gatheringEvent.1.leg").$(".glyphicon-user").isDisplayed()).toBe(true);
+    }));
+    describe("namedPlaceNotes", () => {
+        it("renders", () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(yield form.$locate("gatherings.0.namedPlaceNotes").isDisplayed()).toBe(true);
+        }));
+        it("is textarea", () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(yield form.$getTextareaWidget("gatherings.0.namedPlaceNotes").isDisplayed()).toBe(true);
+        }));
+        it("updates", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield test_utils_1.updateValue(form.$getTextareaWidget("gatherings.0.namedPlaceNotes"), "test");
+            expect(yield form.$getTextareaWidget("gatherings.0.namedPlaceNotes").getAttribute("value")).toBe("test");
+            expect((yield form.getChangedData()).gatheringEvent.namedPlaceNotes).toBe("test");
+        }));
+        it("doesn't spill into gatherings", () => __awaiter(void 0, void 0, void 0, function* () {
+            expect((yield form.getChangedData()).gatherings[0]).not.toContain("namedPlaceNotes");
+        }));
+    });
+    it("added existing user ID is shown", () => __awaiter(void 0, void 0, void 0, function* () {
+        const $input = form.$getInputWidget("gatheringEvent.1.leg");
+        expect(yield $input.getAttribute("value")).toMatch(/Unit.+ \(MA\.\d+\)/);
+    }));
+    it("entering descriptionBiotopeF doesn't clear observerCount", () => __awaiter(void 0, void 0, void 0, function* () {
+        form = yield test_utils_1.createForm({ id: "MHL.3", localFormData: true, isAdmin: true });
+        const $descriptionBiotopeF = form.$locate("gatherings.0.gatheringFact.descriptionBiotopeF");
+        const $otherBiotopeFCheckbox = $descriptionBiotopeF.$$(".checkbox label input").get(2);
+        yield $otherBiotopeFCheckbox.click();
+        yield $otherBiotopeFCheckbox.click();
+        yield $otherBiotopeFCheckbox.click();
+        //await $descriptionBiotopeF.$("input.form-control").sendKeys("test");
+        const formData = yield form.getChangedData();
+        expect(formData.gatherings[0].gatheringFact.observerCount).toBe(1);
+    }));
+});

package/tsconfig.test.json

@@ -5,6 +5,6 @@
 		"declaration": true
 	},
 	"include": [
-		"./test/test-utils.ts"
+		"./test/**/*"
 	]
 }

package/xsel -b

@@ -0,0 +1,9 @@
+                                    "toggleable": {
+                                        "query": {
+											"informalTaxonGroup": "MVL.1",
+											"onlyFinnish": true
+                                        },
+										"glyphClass": "informal-group-image MVL.1",
+										"placeholder": "",
+										"tooltip": "Aloita suomalaisten lintujen syöttö"
+                                    },

package/cypress/fixtures/example.json

@@ -1,5 +0,0 @@
-{
-  "name": "Using fixtures to represent data",
-  "email": "hello@cypress.io",
-  "body": "Fixtures are a great way to mock data for responses to routes"
-}

package/lib/ApiClient.d.ts

@@ -1,46 +0,0 @@
-import { Translations, Lang } from "./components/LajiForm";
-interface Query {
-    [param: string]: any;
-}
-interface Options {
-    failSilently?: boolean;
-    [option: string]: any;
-}
-export interface ApiClientImplementation {
-    fetch: (path: string, query: Query, options: any) => Promise<any>;
-}
-/**
- * ApiClient "interface". Wraps the given apiClient as a singleton object.
- * Given apiClient must implement fetch().
- */
-export default class ApiClient {
-    apiClient: ApiClientImplementation;
-    lang: Lang;
-    translations: Translations;
-    cache: {
-        [path: string]: {
-            [cacheKey: string]: Promise<any>;
-        };
-    };
-    on: {
-        [path: string]: (() => void)[];
-    };
-    constructor(apiClient: ApiClientImplementation, lang: Lang | undefined, translations: Translations);
-    /**
-     * Implementing apiClient must return a promise that passes the raw response as 1st arg.
-     * @param path URL for GET.
-     * @param query Object, where keys are param names and values are param values.
-     * @returns a Promise.
-     */
-    fetchRaw(path: string, query?: Query, options?: any): Promise<any>;
-    fetch<T>(path: string, query?: Query, options?: Options): Promise<T>;
-    getCacheKey(query?: Query, options?: Options): string;
-    fetchCached<T>(path: string, query?: Query, options?: Options): Promise<T>;
-    invalidateCachePath(path: string): void;
-    invalidateCachePathQuery(path: string, query: string): void;
-    flushCache: () => void;
-    onCachePathInvalidation(path: string, callback: () => void): void;
-    removeOnCachePathInvalidation(path: string, callback: () => void): void;
-    setLang(lang: Lang): void;
-}
-export {};

package/lib/ApiClient.js

@@ -1,93 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * ApiClient "interface". Wraps the given apiClient as a singleton object.
- * Given apiClient must implement fetch().
- */
-class ApiClient {
-    constructor(apiClient, lang = "en", translations) {
-        this.cache = {};
-        this.on = {};
-        this.flushCache = () => {
-            this.cache = {};
-        };
-        this.apiClient = apiClient;
-        this.lang = lang;
-        this.translations = translations;
-    }
-    /**
-     * Implementing apiClient must return a promise that passes the raw response as 1st arg.
-     * @param path URL for GET.
-     * @param query Object, where keys are param names and values are param values.
-     * @returns a Promise.
-     */
-    fetchRaw(path, query, options) {
-        const _query = Object.assign({ lang: this.lang }, (query || {}));
-        if (!_query.lang) {
-            delete _query.lang;
-        }
-        return this.apiClient.fetch(path, _query, options).catch(() => {
-            throw new Error(this.translations[this.lang].RequestFailed);
-        });
-    }
-    fetch(path, query, options = {}) {
-        const { failSilently = false } = options, fetchOptions = __rest(options, ["failSilently"]);
-        return this.fetchRaw(path, query, fetchOptions).then(response => {
-            if (!failSilently && response.status >= 400) {
-                throw new Error("Request failed");
-            }
-            return response.json();
-        }).catch(() => {
-            if (this.cache[path])
-                delete this.cache[path][this.getCacheKey(query, options)];
-            throw new Error(this.translations[this.lang].RequestFailed);
-        });
-    }
-    getCacheKey(query, options) {
-        return JSON.stringify(query) + JSON.stringify(options);
-    }
-    fetchCached(path, query, options) {
-        const cacheKey = this.getCacheKey(query, options);
-        if (!this.cache[path])
-            this.cache[path] = {};
-        this.cache[path][cacheKey] = cacheKey in this.cache[path] ? this.cache[path][cacheKey] : this.fetch(path, query, options);
-        return this.cache[path][cacheKey];
-    }
-    invalidateCachePath(path) {
-        delete this.cache[path];
-        if (this.on[path]) {
-            this.on[path].forEach(callback => callback());
-        }
-    }
-    //TODO on invalidation callbacks
-    invalidateCachePathQuery(path, query) {
-        if (this.cache[path])
-            delete this.cache[path][query];
-    }
-    onCachePathInvalidation(path, callback) {
-        if (!this.on[path])
-            this.on[path] = [];
-        this.on[path].push(callback);
-    }
-    removeOnCachePathInvalidation(path, callback) {
-        if (this.on[path]) {
-            this.on[path] = this.on[path].filter(fn => fn !== callback);
-        }
-    }
-    setLang(lang) {
-        this.lang = lang;
-        this.flushCache();
-    }
-}
-exports.default = ApiClient;

package/lib/Context.d.ts

@@ -1,8 +0,0 @@
-declare const _default: (nameSpace?: number | string) => Record<string, unknown>;
-/**
- * A singleton context container for accessing state between components. Should be used for vars that shouldn't affect React change detection, e.g. not suitable to be stored in React context or are updated mutably.
- *
- * Empty namespace "" is used for global vars.
- */
-export default _default;
-export declare function clear(): void;

package/lib/Context.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clear = void 0;
-let singletonContext = {};
-/**
- * A singleton context container for accessing state between components. Should be used for vars that shouldn't affect React change detection, e.g. not suitable to be stored in React context or are updated mutably.
- *
- * Empty namespace "" is used for global vars.
- */
-exports.default = (nameSpace = "") => {
-    if (!singletonContext[nameSpace])
-        singletonContext[nameSpace] = {};
-    return singletonContext[nameSpace];
-};
-function clear() {
-    singletonContext = {};
-}
-exports.clear = clear;

package/lib/ReactContext.d.ts

@@ -1,7 +0,0 @@
-import * as React from "react";
-import { Theme } from "./themes/theme";
-export interface ContextProps {
-    theme: Theme;
-}
-declare const Context: React.Context<ContextProps>;
-export default Context;