@luomus/laji-form 15.1.4 → 15.1.6

package/lib/ApiClient.d.ts

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,93 @@
+"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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,18 @@
+"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

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

package/lib/ReactContext.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const Context = React.createContext({});
+exports.default = Context;

package/lib/components/BaseComponent.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { FieldProps, WidgetProps } from "./LajiForm";
+declare type Constructor<T> = new (...args: any[]) => T;
+interface LajiFormComponentForBaseComponent<P, S> extends React.Component<P, S> {
+    getStateFromProps?(props: P): S;
+    UNSAFE_componentWillReceiveProps?(props: Readonly<P>, nextContext?: any): void;
+}
+export declare function BaseComponent<P extends FieldProps | WidgetProps, S, LFC extends Constructor<LajiFormComponentForBaseComponent<P, S>>>(ComposedComponent: LFC): any;
+export default BaseComponent;

package/lib/components/BaseComponent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseComponent = void 0;
+const utils_1 = require("../utils");
+function BaseComponent(ComposedComponent) {
+    var _a;
+    return _a = class BaseComponent extends ComposedComponent {
+            constructor(...args) {
+                const props = args[0];
+                super(props);
+                if (!this.state && this.getStateFromProps)
+                    this.state = this.getStateFromProps(props);
+            }
+            UNSAFE_componentWillReceiveProps(props, nextContext) {
+                if (super.UNSAFE_componentWillReceiveProps) {
+                    super.UNSAFE_componentWillReceiveProps(props, nextContext);
+                }
+                else if (this.getStateFromProps) {
+                    const state = this.getStateFromProps(props);
+                    if (state)
+                        this.setState(state);
+                }
+            }
+        },
+        _a.displayName = utils_1.getReactComponentName(ComposedComponent),
+        _a;
+}
+exports.BaseComponent = BaseComponent;
+exports.default = BaseComponent;

package/lib/components/LajiForm.d.ts

@@ -0,0 +1,221 @@
+import * as React from "react";
+import * as PropTypes from "prop-types";
+import { FailedBackgroundJobsPanel } from "./components";
+import { ReactUtilsType } from "../utils";
+import { HasMaybeChildren, Theme } from "../themes/theme";
+import { ContextProps } from "../ReactContext";
+import Form from "@rjsf/core";
+import { FieldProps as RJSFFieldProps, WidgetProps as RJSFWidgetProps, Field, Widget, TemplatesType } from "@rjsf/utils";
+import ApiClient, { ApiClientImplementation } from "../ApiClient";
+import KeyHandlerService, { ShortcutKeys } from "../services/key-handler-service";
+import SettingsService, { Settings } from "../services/settings-service";
+import FocusService from "../services/focus-service";
+import BlockerService from "../services/blocker-service";
+import CustomEventService from "../services/custom-event-service";
+import SubmitHookService, { SubmitHook } from "../services/submit-hook-service";
+import DOMIdService from "../services/dom-id-service";
+import IdService from "../services/id-service";
+import RootInstanceService from "../services/root-instance-service";
+import SingletonMapService from "../services/singleton-map-service";
+export interface LajiFormProps extends HasMaybeChildren {
+    apiClient?: ApiClientImplementation;
+    lang?: Lang;
+    formData?: any;
+    schema?: any;
+    uiSchema?: any;
+    topOffset?: number;
+    bottomOffset?: number;
+    formContext?: any;
+    uiSchemaContext?: any;
+    settings?: any;
+    id?: string;
+    googleApiKey?: string;
+    notifier?: Notifier;
+    fields?: {
+        [name: string]: Field;
+    };
+    widgets?: {
+        [name: string]: Widget;
+    };
+    templates?: {
+        [name: string]: TemplatesType;
+    };
+    autoFocus?: boolean;
+    componentDidMount?: () => void;
+    onError?: (e: Error, i: React.ErrorInfo) => void;
+    onChange?: (formData: any) => void;
+    optimizeOnChange?: boolean;
+    showShortcutButton?: boolean;
+    renderSubmit?: boolean;
+    submitText?: string;
+    onSubmit?: (data: {
+        formData: any;
+    }) => void;
+    onValidationError?: (extraErrors: any) => void;
+    validators?: any;
+    warnings?: any;
+    onSettingsChange?: (settings: any, global: boolean) => void;
+    mediaMetadata?: MediaMetadata;
+    theme?: Theme;
+    lajiGeoServerAddress?: string;
+}
+export interface LajiFormState {
+    submitHooks?: SubmitHook[];
+    formContext: FormContext;
+    formData?: any;
+    extraErrors?: any;
+    error?: boolean;
+    runningSubmitHooks?: boolean;
+}
+export interface MediaMetadata {
+    capturerVerbatim: string;
+    intellectualOwner: string;
+    intellectualRights: string;
+}
+export interface FormContext {
+    translations: ByLang;
+    lang: Lang;
+    uiSchemaContext: any;
+    formRef: React.RefObject<Form>;
+    topOffset: number;
+    bottomOffset: number;
+    formID: string;
+    googleApiKey: string;
+    notifier: Notifier;
+    apiClient: ApiClient;
+    Label: React.Component;
+    formDataTransformers?: any[];
+    _parentLajiFormId?: number;
+    mediaMetadata?: MediaMetadata;
+    contextId: number;
+    theme: Theme;
+    setTimeout: (fn: () => void, time?: number) => void;
+    utils: ReactUtilsType;
+    lajiGeoServerAddress: string;
+    globals: Record<string, unknown>;
+    services: {
+        keyHandler: KeyHandlerService;
+        settings: SettingsService;
+        focus: FocusService;
+        blocker: BlockerService;
+        customEvents: CustomEventService;
+        submitHooks: SubmitHookService;
+        DOMIds: DOMIdService;
+        ids: IdService;
+        rootInstance: RootInstanceService;
+        singletonMap: SingletonMapService;
+    };
+}
+export declare type Lang = "fi" | "en" | "sv";
+export interface FieldProps extends RJSFFieldProps<any, any, FormContext> {
+    uiSchema: any;
+    errorSchema: any;
+    formContext: FormContext;
+}
+export interface WidgetProps extends RJSFWidgetProps<any, any, FormContext> {
+    uiSchema: any;
+    errorSchema: any;
+    formContext: FormContext;
+}
+export declare type NotifyMessager = (msg: string) => void;
+export interface Notifier {
+    success: NotifyMessager;
+    info: NotifyMessager;
+    warning: NotifyMessager;
+    error: NotifyMessager;
+}
+export declare type ByLang = {
+    [key: string]: string;
+};
+export declare type Translations = Record<Lang, ByLang>;
+export default class LajiForm extends React.Component<LajiFormProps, LajiFormState> {
+    static contextType: React.Context<ContextProps>;
+    private contextMemoizeKey;
+    private contextFormMemoizeKey;
+    memoizedContext: ContextProps;
+    memoizedFormContext: FormContext;
+    translations: Translations;
+    bgJobRef: React.RefObject<FailedBackgroundJobsPanel>;
+    shortcutHelpRef: React.RefObject<any>;
+    apiClient: ApiClient;
+    _id: number;
+    propagateSubmit: boolean;
+    formRef: React.RefObject<Form<any, import("@rjsf/utils").RJSFSchema, any>>;
+    mounted: boolean;
+    keyCombo: string;
+    defaultNotifier: Notifier;
+    validating: boolean;
+    cachedNonliveValidations: any;
+    helpVisible: boolean;
+    helpTimeout: number;
+    helpStarted: boolean;
+    eventListeners: [typeof document | typeof window, string, (e: Event) => void][];
+    timeouts: number[];
+    static propTypes: {
+        uiSchemaContext: PropTypes.Requireable<object>;
+        settings: PropTypes.Requireable<object>;
+        validators: PropTypes.Requireable<object>;
+        warnings: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        lang: Lang;
+        schema: {};
+        uiSchema: {};
+    };
+    constructor(props: LajiFormProps);
+    UNSAFE_componentWillReceiveProps(props: LajiFormProps): void;
+    getStateFromProps(props: LajiFormProps): LajiFormState;
+    getMemoizedFormContext(props: LajiFormProps): FormContext;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidCatch(e: Error, i: React.ErrorInfo): void;
+    componentDidUpdate(prevProps: LajiFormProps): void;
+    onSubmitHooksChange: (submitHooks: SubmitHook[], callback?: (() => void) | undefined) => void;
+    resetShortcuts(shortcuts?: ShortcutKeys): void;
+    constructTranslations(): Translations;
+    getDefaultNotifier: () => Notifier;
+    onChange: ({ formData }: {
+        formData: any;
+    }) => void;
+    getFields: (_fields?: {
+        [name: string]: Field<any, import("@rjsf/utils").RJSFSchema, any>;
+    } | undefined) => {
+        [x: string]: Field<any, import("@rjsf/utils").RJSFSchema, any>;
+    };
+    getWidgets: (_widgets?: {
+        [name: string]: Widget<any, import("@rjsf/utils").RJSFSchema, any>;
+    } | undefined) => {
+        [x: string]: Widget<any, import("@rjsf/utils").RJSFSchema, any>;
+    };
+    getTemplates: (_templates?: {
+        [name: string]: TemplatesType<any, import("@rjsf/utils").RJSFSchema, any>;
+    } | undefined) => {
+        [x: string]: TemplatesType<any, import("@rjsf/utils").RJSFSchema, any>;
+    };
+    getContext: (props: LajiFormProps, context: ContextProps) => ContextProps;
+    render(): JSX.Element | null;
+    renderSubmitHooks: () => JSX.Element | null | undefined;
+    validateAndSubmit: (warnings?: boolean, onlySchema?: boolean) => Promise<void>;
+    validate: (warnings?: boolean, nonlive?: boolean, onlySchema?: boolean) => Promise<unknown>;
+    onSubmit: (onlySchemaValidations?: "onlySchemaValidations" | undefined) => false | undefined;
+    popErrorListIfNeeded: () => void;
+    _onDefaultSubmit: (e: React.SyntheticEvent) => void;
+    submit: () => void;
+    submitOnlySchemaValidations: () => void;
+    getShorcutButtonTooltip: () => string | undefined;
+    toggleHelp: (e: React.MouseEvent) => void;
+    showHelp: () => void;
+    dismissHelp: (e: Event | React.SyntheticEvent) => void;
+    keyFunctions: {
+        navigate: (e: KeyboardEvent, { reverse }: any) => void;
+        help: (e: KeyboardEvent, { delay }: any) => boolean;
+        revalidate: () => void;
+    };
+    pushBlockingLoader: () => void;
+    popBlockingLoader: () => void;
+    getSettings(global?: boolean): {};
+    onSettingsChange: (settings: Settings, global?: boolean) => void;
+    addEventListener: (target: typeof document | typeof window, name: string, fn: (e: Event) => void) => void;
+    setTimeout: (fn: () => void, time?: number) => number;
+    destroy: () => void;
+}