@diplodoc/components 0.0.0-rc-pdf-icon-custimization-24387828749

package/build/cjs/hoc/withLang.d.ts

@@ -0,0 +1,57 @@
+import type { Lang } from '../contexts/LangContext';
+export interface WithLangProps {
+    lang: Lang;
+}
+declare const _default: <T extends Record<string, any>>(Component: React.ComponentType<any>) => {
+    new (props: Omit<T, "lang">): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "lang">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "lang">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Omit<T, "lang">, context: any): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "lang">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "lang">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "lang">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "lang">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "lang">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: import("react").Context<any> & {
+        name?: string;
+    };
+};
+export default _default;

package/build/cjs/hoc/withLang.js

@@ -0,0 +1,39 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hoc/withLang.ts
+var withLang_exports = {};
+__export(withLang_exports, {
+  default: () => withLang_default
+});
+module.exports = __toCommonJS(withLang_exports);
+var import_LangContext = __toESM(require("../contexts/LangContext"));
+var import_withContext = __toESM(require("./_withContext"));
+var withLang_default = (0, import_withContext.default)("lang", import_LangContext.default);
+//# sourceMappingURL=withLang.js.map

package/build/cjs/hoc/withLang.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/withLang.ts"],
+  "sourcesContent": ["import type {Lang} from '../contexts/LangContext';\n\nimport LangContext from '../contexts/LangContext';\n\nimport withPropContext from './_withContext';\n\nexport interface WithLangProps {\n    lang: Lang;\n}\n\nexport default withPropContext<WithLangProps>('lang', LangContext);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,yBAAwB;AAExB,yBAA4B;AAM5B,IAAO,uBAAQ,mBAAAA,SAA+B,QAAQ,mBAAAC,OAAW;",
+  "names": ["withPropContext", "LangContext"]
+}

package/build/cjs/hoc/withRouter.d.ts

@@ -0,0 +1,57 @@
+import type { RouterData } from '../contexts/RouterContext';
+export interface WithRouterProps {
+    router: RouterData;
+}
+declare const _default: <T extends Record<string, any>>(Component: React.ComponentType<any>) => {
+    new (props: Omit<T, "router">): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "router">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "router">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Omit<T, "router">, context: any): {
+        render(): import("react").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<T, "router">>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<T, "router">>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<T, "router">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<T, "router">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<T, "router">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: import("react").Context<any> & {
+        name?: string;
+    };
+};
+export default _default;

package/build/cjs/hoc/withRouter.js

@@ -0,0 +1,39 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hoc/withRouter.ts
+var withRouter_exports = {};
+__export(withRouter_exports, {
+  default: () => withRouter_default
+});
+module.exports = __toCommonJS(withRouter_exports);
+var import_RouterContext = __toESM(require("../contexts/RouterContext"));
+var import_withContext = __toESM(require("./_withContext"));
+var withRouter_default = (0, import_withContext.default)("router", import_RouterContext.default);
+//# sourceMappingURL=withRouter.js.map

package/build/cjs/hoc/withRouter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/withRouter.ts"],
+  "sourcesContent": ["import type {RouterData} from '../contexts/RouterContext';\n\nimport RouterContext from '../contexts/RouterContext';\n\nimport withPropContext from './_withContext';\n\nexport interface WithRouterProps {\n    router: RouterData;\n}\n\nexport default withPropContext<WithRouterProps>('router', RouterContext);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,2BAA0B;AAE1B,yBAA4B;AAM5B,IAAO,yBAAQ,mBAAAA,SAAiC,UAAU,qBAAAC,OAAa;",
+  "names": ["withPropContext", "RouterContext"]
+}

package/build/cjs/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from './usePopper';
+export * from './useTimer';
+export * from './useTranslation';
+export * from './usePopupState';
+export * from './useAnalytics';
+export * from './useVirtualElementRef';
+export * from './useShareHandler';
+export * from './useInterface';

package/build/cjs/hooks/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/index.ts
+var hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);
+__reExport(hooks_exports, require("./usePopper"), module.exports);
+__reExport(hooks_exports, require("./useTimer"), module.exports);
+__reExport(hooks_exports, require("./useTranslation"), module.exports);
+__reExport(hooks_exports, require("./usePopupState"), module.exports);
+__reExport(hooks_exports, require("./useAnalytics"), module.exports);
+__reExport(hooks_exports, require("./useVirtualElementRef"), module.exports);
+__reExport(hooks_exports, require("./useShareHandler"), module.exports);
+__reExport(hooks_exports, require("./useInterface"), module.exports);
+//# sourceMappingURL=index.js.map

package/build/cjs/hooks/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/index.ts"],
+  "sourcesContent": ["export * from './usePopper';\nexport * from './useTimer';\nexport * from './useTranslation';\nexport * from './usePopupState';\nexport * from './useAnalytics';\nexport * from './useVirtualElementRef';\nexport * from './useShareHandler';\nexport * from './useInterface';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,wBAAd;AACA,0BAAc,uBADd;AAEA,0BAAc,6BAFd;AAGA,0BAAc,4BAHd;AAIA,0BAAc,2BAJd;AAKA,0BAAc,mCALd;AAMA,0BAAc,8BANd;AAOA,0BAAc,2BAPd;",
+  "names": []
+}

package/build/cjs/hooks/useAnalytics.d.ts

@@ -0,0 +1,22 @@
+import type { Router } from '../models';
+type GtagEventFunction = (data: {
+    type?: string;
+    event?: string;
+    action?: string;
+    params?: Record<string, string | number | undefined>;
+}, force?: boolean) => void;
+declare global {
+    interface Window {
+        gtag: undefined | null | GtagEventFunction;
+    }
+}
+export type AnalyticsParams = {
+    gtmId: string;
+    router: Router;
+    useConsent?: boolean;
+    consentMode?: 'base' | 'notification';
+};
+export declare const useAnalytics: ({ gtmId, router, useConsent }: AnalyticsParams) => {
+    sendEvent: GtagEventFunction;
+};
+export {};

package/build/cjs/hooks/useAnalytics.js

@@ -0,0 +1,109 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/useAnalytics.ts
+var useAnalytics_exports = {};
+__export(useAnalytics_exports, {
+  useAnalytics: () => useAnalytics
+});
+module.exports = __toCommonJS(useAnalytics_exports);
+var import_react = __toESM(require("react"));
+var import_react_gtm_module = __toESM(require("react-gtm-module"));
+var useAnalytics = ({ gtmId, router, useConsent }) => {
+  const [gtmInitialized, setGtmInitialized] = import_react.default.useState(false);
+  const sendEvent = import_react.default.useCallback(
+    (data, force) => {
+      if (!useConsent && !force) {
+        return;
+      }
+      import_react_gtm_module.default.dataLayer({ dataLayer: data });
+    },
+    [useConsent]
+  );
+  import_react.default.useEffect(() => {
+    if (!gtmId) {
+      return;
+    }
+    if (!gtmInitialized) {
+      import_react_gtm_module.default.initialize({
+        gtmId,
+        dataLayer: []
+      });
+      setGtmInitialized(true);
+    }
+    sendEvent(
+      {
+        type: "consent",
+        action: "default",
+        params: {
+          analytics_storage: useConsent ? "granted" : "denied",
+          wait_for_update: useConsent ? 0 : Infinity
+        }
+      },
+      true
+    );
+    sendEvent(
+      {
+        event: "default_consent"
+      },
+      true
+    );
+  }, [gtmId, sendEvent]);
+  import_react.default.useEffect(() => {
+    if (!gtmInitialized) {
+      return;
+    }
+    sendEvent(
+      {
+        type: "consent",
+        action: "update",
+        params: {
+          analytics_storage: useConsent ? "granted" : "denied"
+        }
+      },
+      true
+    );
+  }, [useConsent]);
+  import_react.default.useEffect(() => {
+    if (!gtmInitialized) {
+      return;
+    }
+    sendEvent({
+      type: "config",
+      action: gtmId,
+      params: {
+        page_path: router.pathname
+      }
+    });
+  }, [gtmInitialized, sendEvent, gtmId, router.pathname]);
+  return {
+    sendEvent
+  };
+};
+//# sourceMappingURL=useAnalytics.js.map

package/build/cjs/hooks/useAnalytics.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useAnalytics.ts"],
+  "sourcesContent": ["import type {Router} from '../models';\n\nimport React from 'react';\nimport TagManager from 'react-gtm-module';\n\ntype GtagEventFunction = (\n    data: {\n        type?: string;\n        event?: string;\n        action?: string;\n        params?: Record<string, string | number | undefined>;\n    },\n    force?: boolean,\n) => void;\n\ndeclare global {\n    interface Window {\n        gtag: undefined | null | GtagEventFunction;\n    }\n}\n\nexport type AnalyticsParams = {\n    gtmId: string;\n    router: Router;\n    useConsent?: boolean;\n    consentMode?: 'base' | 'notification';\n};\n\nexport const useAnalytics = ({gtmId, router, useConsent}: AnalyticsParams) => {\n    const [gtmInitialized, setGtmInitialized] = React.useState(false);\n\n    const sendEvent = React.useCallback<GtagEventFunction>(\n        (data, force) => {\n            if (!useConsent && !force) {\n                return;\n            }\n            TagManager.dataLayer({dataLayer: data});\n        },\n        [useConsent],\n    );\n\n    React.useEffect(() => {\n        if (!gtmId) {\n            return;\n        }\n        if (!gtmInitialized) {\n            TagManager.initialize({\n                gtmId,\n                dataLayer: [],\n            });\n            setGtmInitialized(true);\n        }\n        sendEvent(\n            {\n                type: 'consent',\n                action: 'default',\n                params: {\n                    analytics_storage: useConsent ? 'granted' : 'denied',\n                    wait_for_update: useConsent ? 0 : Infinity,\n                },\n            },\n            true,\n        );\n        sendEvent(\n            {\n                event: 'default_consent',\n            },\n            true,\n        );\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [gtmId, sendEvent]);\n\n    React.useEffect(() => {\n        if (!gtmInitialized) {\n            return;\n        }\n        sendEvent(\n            {\n                type: 'consent',\n                action: 'update',\n                params: {\n                    analytics_storage: useConsent ? 'granted' : 'denied',\n                },\n            },\n            true,\n        );\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [useConsent]);\n\n    React.useEffect(() => {\n        if (!gtmInitialized) {\n            return;\n        }\n        sendEvent({\n            type: 'config',\n            action: gtmId,\n            params: {\n                page_path: router.pathname,\n            },\n        });\n    }, [gtmInitialized, sendEvent, gtmId, router.pathname]);\n\n    return {\n        sendEvent,\n    };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAAkB;AAClB,8BAAuB;AAyBhB,IAAM,eAAe,CAAC,EAAC,OAAO,QAAQ,WAAU,MAAuB;AAC1E,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,aAAAA,QAAM,SAAS,KAAK;AAEhE,QAAM,YAAY,aAAAA,QAAM;AAAA,IACpB,CAAC,MAAM,UAAU;AACb,UAAI,CAAC,cAAc,CAAC,OAAO;AACvB;AAAA,MACJ;AACA,8BAAAC,QAAW,UAAU,EAAC,WAAW,KAAI,CAAC;AAAA,IAC1C;AAAA,IACA,CAAC,UAAU;AAAA,EACf;AAEA,eAAAD,QAAM,UAAU,MAAM;AAClB,QAAI,CAAC,OAAO;AACR;AAAA,IACJ;AACA,QAAI,CAAC,gBAAgB;AACjB,8BAAAC,QAAW,WAAW;AAAA,QAClB;AAAA,QACA,WAAW,CAAC;AAAA,MAChB,CAAC;AACD,wBAAkB,IAAI;AAAA,IAC1B;AACA;AAAA,MACI;AAAA,QACI,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,QAAQ;AAAA,UACJ,mBAAmB,aAAa,YAAY;AAAA,UAC5C,iBAAiB,aAAa,IAAI;AAAA,QACtC;AAAA,MACJ;AAAA,MACA;AAAA,IACJ;AACA;AAAA,MACI;AAAA,QACI,OAAO;AAAA,MACX;AAAA,MACA;AAAA,IACJ;AAAA,EAEJ,GAAG,CAAC,OAAO,SAAS,CAAC;AAErB,eAAAD,QAAM,UAAU,MAAM;AAClB,QAAI,CAAC,gBAAgB;AACjB;AAAA,IACJ;AACA;AAAA,MACI;AAAA,QACI,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,QAAQ;AAAA,UACJ,mBAAmB,aAAa,YAAY;AAAA,QAChD;AAAA,MACJ;AAAA,MACA;AAAA,IACJ;AAAA,EAEJ,GAAG,CAAC,UAAU,CAAC;AAEf,eAAAA,QAAM,UAAU,MAAM;AAClB,QAAI,CAAC,gBAAgB;AACjB;AAAA,IACJ;AACA,cAAU;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,QAAQ;AAAA,QACJ,WAAW,OAAO;AAAA,MACtB;AAAA,IACJ,CAAC;AAAA,EACL,GAAG,CAAC,gBAAgB,WAAW,OAAO,OAAO,QAAQ,CAAC;AAEtD,SAAO;AAAA,IACH;AAAA,EACJ;AACJ;",
+  "names": ["React", "TagManager"]
+}

package/build/cjs/hooks/useInterface.d.ts

@@ -0,0 +1 @@
+export declare function useInterface(name: string): boolean;

package/build/cjs/hooks/useInterface.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/useInterface.ts
+var useInterface_exports = {};
+__export(useInterface_exports, {
+  useInterface: () => useInterface
+});
+module.exports = __toCommonJS(useInterface_exports);
+var import_react = require("react");
+var import_InterfaceContext = require("../contexts/InterfaceContext");
+function useInterface(name) {
+  const { isHidden } = (0, import_react.useContext)(import_InterfaceContext.InterfaceContext);
+  return isHidden(name);
+}
+//# sourceMappingURL=useInterface.js.map

package/build/cjs/hooks/useInterface.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useInterface.ts"],
+  "sourcesContent": ["import {useContext} from 'react';\n\nimport {InterfaceContext} from '../contexts/InterfaceContext';\n\nexport function useInterface(name: string): boolean {\n    const {isHidden} = useContext(InterfaceContext);\n\n    return isHidden(name);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyB;AAEzB,8BAA+B;AAExB,SAAS,aAAa,MAAuB;AAChD,QAAM,EAAC,SAAQ,QAAI,yBAAW,wCAAgB;AAE9C,SAAO,SAAS,IAAI;AACxB;",
+  "names": []
+}

package/build/cjs/hooks/usePopper.d.ts

@@ -0,0 +1,33 @@
+import type popper from '@popperjs/core';
+import type { Modifier } from 'react-popper';
+import React from 'react';
+export type PopperPlacement = popper.Placement | popper.Placement[];
+export type PopperOffset = [number, number];
+export type PopperModifiers = Modifier<unknown, Record<string, unknown>>[];
+export interface PopperProps {
+    anchor: HTMLElement | null;
+    placement?: PopperPlacement;
+    offset?: [number, number];
+    modifiers?: PopperModifiers;
+}
+export declare enum PopperPosition {
+    BOTTOM_START = "bottom-start",
+    BOTTOM = "bottom",
+    BOTTOM_END = "bottom-end",
+    TOP_START = "top-start",
+    TOP = "top",
+    TOP_END = "top-end",
+    RIGHT_START = "right-start",
+    RIGHT = "right",
+    RIGHT_END = "right-end",
+    LEFT_START = "left-start",
+    LEFT = "left",
+    LEFT_END = "left-end"
+}
+export interface PopoverHook {
+    attributes: Record<string, Record<string, string> | undefined>;
+    styles: Record<string, React.CSSProperties>;
+    setPopperRef: React.Dispatch<React.SetStateAction<HTMLDivElement | null>>;
+    setArrowRef: React.Dispatch<React.SetStateAction<HTMLDivElement | null>>;
+}
+export declare function usePopper(props: PopperProps): PopoverHook;

package/build/cjs/hooks/usePopper.js

@@ -0,0 +1,93 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/usePopper.ts
+var usePopper_exports = {};
+__export(usePopper_exports, {
+  PopperPosition: () => PopperPosition,
+  usePopper: () => usePopper
+});
+module.exports = __toCommonJS(usePopper_exports);
+var import_react = __toESM(require("react"));
+var import_react_popper = require("react-popper");
+var PopperPosition = /* @__PURE__ */ ((PopperPosition2) => {
+  PopperPosition2["BOTTOM_START"] = "bottom-start";
+  PopperPosition2["BOTTOM"] = "bottom";
+  PopperPosition2["BOTTOM_END"] = "bottom-end";
+  PopperPosition2["TOP_START"] = "top-start";
+  PopperPosition2["TOP"] = "top";
+  PopperPosition2["TOP_END"] = "top-end";
+  PopperPosition2["RIGHT_START"] = "right-start";
+  PopperPosition2["RIGHT"] = "right";
+  PopperPosition2["RIGHT_END"] = "right-end";
+  PopperPosition2["LEFT_START"] = "left-start";
+  PopperPosition2["LEFT"] = "left";
+  PopperPosition2["LEFT_END"] = "left-end";
+  return PopperPosition2;
+})(PopperPosition || {});
+var DEFAULT_PLACEMENT = Object.values(PopperPosition);
+function usePopper(props) {
+  const { anchor, placement = DEFAULT_PLACEMENT, offset, modifiers = [] } = props;
+  const [popperElement, setPopperElement] = import_react.default.useState(null);
+  const [arrowElement, setArrowElement] = import_react.default.useState(null);
+  const placements = Array.isArray(placement) ? placement : [placement];
+  const { attributes, styles } = (0, import_react_popper.usePopper)(anchor, popperElement, {
+    strategy: "fixed",
+    modifiers: [
+      { name: "arrow", options: { enabled: Boolean(arrowElement), element: arrowElement } },
+      { name: "offset", options: { offset } },
+      {
+        name: "flip",
+        options: {
+          fallbackPlacements: [
+            "bottom" /* BOTTOM */,
+            "right" /* RIGHT */,
+            "left" /* LEFT */,
+            "top" /* TOP */
+          ]
+        }
+      },
+      {
+        name: "computeStyles",
+        options: {
+          gpuAcceleration: false
+        }
+      },
+      ...modifiers
+    ],
+    placement: placements[0]
+  });
+  return {
+    attributes,
+    styles,
+    setPopperRef: setPopperElement,
+    setArrowRef: setArrowElement
+  };
+}
+//# sourceMappingURL=usePopper.js.map

package/build/cjs/hooks/usePopper.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/usePopper.ts"],
+  "sourcesContent": ["import type popper from '@popperjs/core';\nimport type {Modifier} from 'react-popper';\n\nimport React from 'react';\nimport {usePopper as useReactPopper} from 'react-popper';\n\nexport type PopperPlacement = popper.Placement | popper.Placement[];\nexport type PopperOffset = [number, number];\nexport type PopperModifiers = Modifier<unknown, Record<string, unknown>>[];\n\nexport interface PopperProps {\n    anchor: HTMLElement | null;\n    placement?: PopperPlacement;\n    offset?: [number, number];\n    modifiers?: PopperModifiers;\n}\n\nexport enum PopperPosition {\n    BOTTOM_START = 'bottom-start',\n    BOTTOM = 'bottom',\n    BOTTOM_END = 'bottom-end',\n    TOP_START = 'top-start',\n    TOP = 'top',\n    TOP_END = 'top-end',\n    RIGHT_START = 'right-start',\n    RIGHT = 'right',\n    RIGHT_END = 'right-end',\n    LEFT_START = 'left-start',\n    LEFT = 'left',\n    LEFT_END = 'left-end',\n}\n\nconst DEFAULT_PLACEMENT: PopperPlacement = Object.values(PopperPosition);\n\nexport interface PopoverHook {\n    attributes: Record<string, Record<string, string> | undefined>;\n    styles: Record<string, React.CSSProperties>;\n    setPopperRef: React.Dispatch<React.SetStateAction<HTMLDivElement | null>>;\n    setArrowRef: React.Dispatch<React.SetStateAction<HTMLDivElement | null>>;\n}\n\nexport function usePopper(props: PopperProps): PopoverHook {\n    const {anchor, placement = DEFAULT_PLACEMENT, offset, modifiers = []} = props;\n\n    const [popperElement, setPopperElement] = React.useState<HTMLDivElement | null>(null);\n    const [arrowElement, setArrowElement] = React.useState<HTMLDivElement | null>(null);\n    const placements = Array.isArray(placement) ? placement : [placement];\n\n    const {attributes, styles} = useReactPopper(anchor, popperElement, {\n        strategy: 'fixed',\n        modifiers: [\n            {name: 'arrow', options: {enabled: Boolean(arrowElement), element: arrowElement}},\n            {name: 'offset', options: {offset}},\n            {\n                name: 'flip',\n                options: {\n                    fallbackPlacements: [\n                        PopperPosition.BOTTOM,\n                        PopperPosition.RIGHT,\n                        PopperPosition.LEFT,\n                        PopperPosition.TOP,\n                    ],\n                },\n            },\n            {\n                name: 'computeStyles',\n                options: {\n                    gpuAcceleration: false,\n                },\n            },\n            ...modifiers,\n        ],\n        placement: placements[0],\n    });\n\n    return {\n        attributes,\n        styles,\n        setPopperRef: setPopperElement,\n        setArrowRef: setArrowElement,\n    };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAAkB;AAClB,0BAA0C;AAanC,IAAK,iBAAL,kBAAKA,oBAAL;AACH,EAAAA,gBAAA,kBAAe;AACf,EAAAA,gBAAA,YAAS;AACT,EAAAA,gBAAA,gBAAa;AACb,EAAAA,gBAAA,eAAY;AACZ,EAAAA,gBAAA,SAAM;AACN,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,iBAAc;AACd,EAAAA,gBAAA,WAAQ;AACR,EAAAA,gBAAA,eAAY;AACZ,EAAAA,gBAAA,gBAAa;AACb,EAAAA,gBAAA,UAAO;AACP,EAAAA,gBAAA,cAAW;AAZH,SAAAA;AAAA,GAAA;AAeZ,IAAM,oBAAqC,OAAO,OAAO,cAAc;AAShE,SAAS,UAAU,OAAiC;AACvD,QAAM,EAAC,QAAQ,YAAY,mBAAmB,QAAQ,YAAY,CAAC,EAAC,IAAI;AAExE,QAAM,CAAC,eAAe,gBAAgB,IAAI,aAAAC,QAAM,SAAgC,IAAI;AACpF,QAAM,CAAC,cAAc,eAAe,IAAI,aAAAA,QAAM,SAAgC,IAAI;AAClF,QAAM,aAAa,MAAM,QAAQ,SAAS,IAAI,YAAY,CAAC,SAAS;AAEpE,QAAM,EAAC,YAAY,OAAM,QAAI,oBAAAC,WAAe,QAAQ,eAAe;AAAA,IAC/D,UAAU;AAAA,IACV,WAAW;AAAA,MACP,EAAC,MAAM,SAAS,SAAS,EAAC,SAAS,QAAQ,YAAY,GAAG,SAAS,aAAY,EAAC;AAAA,MAChF,EAAC,MAAM,UAAU,SAAS,EAAC,OAAM,EAAC;AAAA,MAClC;AAAA,QACI,MAAM;AAAA,QACN,SAAS;AAAA,UACL,oBAAoB;AAAA,YAChB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACJ;AAAA,QACJ;AAAA,MACJ;AAAA,MACA;AAAA,QACI,MAAM;AAAA,QACN,SAAS;AAAA,UACL,iBAAiB;AAAA,QACrB;AAAA,MACJ;AAAA,MACA,GAAG;AAAA,IACP;AAAA,IACA,WAAW,WAAW,CAAC;AAAA,EAC3B,CAAC;AAED,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd,aAAa;AAAA,EACjB;AACJ;",
+  "names": ["PopperPosition", "React", "useReactPopper"]
+}

package/build/cjs/hooks/usePopupState.d.ts

@@ -0,0 +1,8 @@
+export declare const usePopupState: ({ autoclose }?: {
+    autoclose?: number;
+}) => {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    readonly visible: boolean;
+};