@pallasoft/ps-core-components 2.42.0 → 2.44.0

package/dist/esm/services/ps-scroll-restore-service.js

@@ -0,0 +1,52 @@
+import { PsScrollRestorationConfig } from '../constants/ps-scroll-restoration-config.js';
+import { PsScrollTargetService } from './ps-scroll-target-service.js';
+export class PsScrollRestoreService {
+    static start(element, top, onDone) {
+        let isDone = false;
+        let observer = null;
+        let mutations = null;
+        let timer = 0;
+        const finish = () => {
+            if (isDone)
+                return;
+            isDone = true;
+            window.clearTimeout(timer);
+            observer?.disconnect();
+            mutations?.disconnect();
+            for (const name of PsScrollRestorationConfig.inputEvents)
+                window.removeEventListener(name, onInput, true);
+            onDone();
+        };
+        const onInput = () => finish();
+        const attempt = () => {
+            if (isDone)
+                return;
+            if (PsScrollTargetService.maxTop(element) >= top - PsScrollRestorationConfig.tolerancePx) {
+                PsScrollTargetService.scrollTo(element, top);
+                finish();
+            }
+        };
+        for (const name of PsScrollRestorationConfig.inputEvents)
+            window.addEventListener(name, onInput, { capture: true, passive: true });
+        timer = window.setTimeout(() => {
+            if (isDone)
+                return;
+            PsScrollTargetService.scrollTo(element, top);
+            finish();
+        }, PsScrollRestorationConfig.restoreTimeoutMs);
+        attempt();
+        if (!isDone && typeof MutationObserver !== 'undefined') {
+            mutations = new MutationObserver(attempt);
+            mutations.observe(element === null ? document.body : element, {
+                childList: true,
+                subtree: true,
+            });
+        }
+        if (!isDone && typeof ResizeObserver !== 'undefined') {
+            observer = new ResizeObserver(attempt);
+            for (const node of PsScrollTargetService.observed(element))
+                observer.observe(node);
+        }
+        return finish;
+    }
+}

package/dist/esm/services/ps-scroll-storage-service.js

@@ -0,0 +1,66 @@
+import { PsScrollRestorationConfig } from '../constants/ps-scroll-restoration-config.js';
+export class PsScrollStorageService {
+    static read(key) {
+        const offsets = PsScrollStorageService.memory();
+        return Object.prototype.hasOwnProperty.call(offsets, key) ? offsets[key] : undefined;
+    }
+    static write(key, top) {
+        const offsets = PsScrollStorageService.memory();
+        delete offsets[key];
+        offsets[key] = top;
+        const keys = Object.keys(offsets);
+        const overflow = keys.length - PsScrollRestorationConfig.maxEntries;
+        for (const oldest of keys.slice(0, overflow > 0 ? overflow : 0))
+            delete offsets[oldest];
+        if (PsScrollStorageService.timer !== 0 || typeof window === 'undefined')
+            return;
+        PsScrollStorageService.timer = window.setTimeout(PsScrollStorageService.flush, PsScrollRestorationConfig.persistThrottleMs);
+    }
+    static flush() {
+        if (typeof window === 'undefined')
+            return;
+        window.clearTimeout(PsScrollStorageService.timer);
+        PsScrollStorageService.timer = 0;
+        if (PsScrollStorageService.offsets === null)
+            return;
+        try {
+            window.sessionStorage.setItem(PsScrollRestorationConfig.storageKey, JSON.stringify(PsScrollStorageService.offsets));
+        }
+        catch {
+            return;
+        }
+    }
+    static reset() {
+        if (typeof window !== 'undefined')
+            window.clearTimeout(PsScrollStorageService.timer);
+        PsScrollStorageService.timer = 0;
+        PsScrollStorageService.offsets = null;
+    }
+    static memory() {
+        if (PsScrollStorageService.offsets === null)
+            PsScrollStorageService.offsets = PsScrollStorageService.load();
+        return PsScrollStorageService.offsets;
+    }
+    static load() {
+        if (typeof window === 'undefined')
+            return {};
+        try {
+            const raw = window.sessionStorage.getItem(PsScrollRestorationConfig.storageKey);
+            if (raw === null)
+                return {};
+            const parsed = JSON.parse(raw);
+            return PsScrollStorageService.isOffsets(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    static isOffsets(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.values(value).every((entry) => typeof entry === 'number' && Number.isFinite(entry)));
+    }
+}
+PsScrollStorageService.offsets = null;
+PsScrollStorageService.timer = 0;

package/dist/esm/services/ps-scroll-target-service.js

@@ -0,0 +1,29 @@
+import { PsScrollRestorationConfig } from '../constants/ps-scroll-restoration-config.js';
+export class PsScrollTargetService {
+    static storageKey(element, restoreKey) {
+        return `${element === null ? PsScrollRestorationConfig.windowScope : PsScrollRestorationConfig.elementScope}${restoreKey}`;
+    }
+    static top(element) {
+        return element === null ? window.scrollY : element.scrollTop;
+    }
+    static maxTop(element) {
+        if (element !== null)
+            return element.scrollHeight - element.clientHeight;
+        return document.documentElement.scrollHeight - window.innerHeight;
+    }
+    static scrollTo(element, top) {
+        if (element === null) {
+            window.scrollTo({ behavior: 'instant', left: 0, top });
+            return;
+        }
+        element.scrollTo({ behavior: 'instant', left: 0, top });
+    }
+    static eventTarget(element) {
+        return element === null ? window : element;
+    }
+    static observed(element) {
+        if (element === null)
+            return [document.documentElement, document.body];
+        return [element, ...Array.from(element.children)];
+    }
+}

package/dist/hooks/use-ps-browser-layout-effect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from 'react';
+export declare const usePsBrowserLayoutEffect: typeof useEffect;

package/dist/hooks/use-ps-browser-layout-effect.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsBrowserLayoutEffect = void 0;
+const react_1 = require("react");
+exports.usePsBrowserLayoutEffect = typeof window === 'undefined' ? react_1.useEffect : react_1.useLayoutEffect;

package/dist/hooks/use-ps-choice-param.d.ts

@@ -0,0 +1,4 @@
+import type { PsChoiceParamData } from '../models/ps-choice-param-data';
+import type { PsChoiceParamOptions } from '../models/ps-choice-param-options';
+import type { PsSearchParamsState } from '../models/ps-search-params-state';
+export declare const usePsChoiceParam: <Value extends string>([searchParams, setSearchParams]: PsSearchParamsState, { fallback, name, options, resetParams }: PsChoiceParamOptions<Value>) => PsChoiceParamData<Value>;

package/dist/hooks/use-ps-choice-param.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsChoiceParam = void 0;
+const ps_query_param_config_1 = require("../constants/ps-query-param-config");
+const ps_query_param_service_1 = require("../services/ps-query-param-service");
+const usePsChoiceParam = ([searchParams, setSearchParams], { fallback, name, options, resetParams }) => ({
+    onChange: (value) => setSearchParams((current) => ps_query_param_service_1.PsQueryParamService.withChoice(current, name, value, fallback, resetParams), ps_query_param_config_1.PsQueryParamConfig.setOptions),
+    value: ps_query_param_service_1.PsQueryParamService.choice(searchParams.get(name), options, fallback),
+});
+exports.usePsChoiceParam = usePsChoiceParam;

package/dist/hooks/use-ps-flag-param.d.ts

@@ -0,0 +1,4 @@
+import type { PsFlagParamData } from '../models/ps-flag-param-data';
+import type { PsFlagParamOptions } from '../models/ps-flag-param-options';
+import type { PsSearchParamsState } from '../models/ps-search-params-state';
+export declare const usePsFlagParam: ([searchParams, setSearchParams]: PsSearchParamsState, { name, resetParams }: PsFlagParamOptions) => PsFlagParamData;

package/dist/hooks/use-ps-flag-param.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsFlagParam = void 0;
+const ps_query_param_config_1 = require("../constants/ps-query-param-config");
+const ps_query_param_service_1 = require("../services/ps-query-param-service");
+const usePsFlagParam = ([searchParams, setSearchParams], { name, resetParams }) => ({
+    isOn: ps_query_param_service_1.PsQueryParamService.flag(searchParams.get(name)),
+    onChange: (isOn) => setSearchParams((current) => ps_query_param_service_1.PsQueryParamService.withFlag(current, name, isOn, resetParams), ps_query_param_config_1.PsQueryParamConfig.setOptions),
+});
+exports.usePsFlagParam = usePsFlagParam;

package/dist/hooks/use-ps-rerender-at.d.ts

@@ -0,0 +1 @@
+export declare const usePsRerenderAt: (atMs: number | null) => number;

package/dist/hooks/use-ps-rerender-at.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsRerenderAt = void 0;
+const react_1 = require("react");
+const ps_rerender_config_1 = require("../constants/ps-rerender-config");
+const usePsRerenderAt = (atMs) => {
+    const [, setTick] = (0, react_1.useState)(0);
+    (0, react_1.useEffect)(() => {
+        if (atMs === null || typeof window === 'undefined')
+            return;
+        let timer = 0;
+        const arm = () => {
+            const remaining = atMs - Date.now();
+            if (remaining <= 0) {
+                setTick((tick) => tick + 1);
+                return;
+            }
+            timer = window.setTimeout(arm, Math.min(remaining, ps_rerender_config_1.PsRerenderConfig.maxTimerMs));
+        };
+        arm();
+        return () => window.clearTimeout(timer);
+    }, [atMs]);
+    return Date.now();
+};
+exports.usePsRerenderAt = usePsRerenderAt;

package/dist/hooks/use-ps-scroll-restoration.d.ts

@@ -0,0 +1,2 @@
+import type { PsScrollRestorationOptions } from '../models/ps-scroll-restoration-options';
+export declare const usePsScrollRestoration: ({ elementRef, preventScrollReset, resetKey, restoreKey, }: PsScrollRestorationOptions) => void;

package/dist/hooks/use-ps-scroll-restoration.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScrollRestoration = void 0;
+const react_1 = require("react");
+const ps_scroll_restore_service_1 = require("../services/ps-scroll-restore-service");
+const ps_scroll_storage_service_1 = require("../services/ps-scroll-storage-service");
+const ps_scroll_target_service_1 = require("../services/ps-scroll-target-service");
+const use_ps_browser_layout_effect_1 = require("./use-ps-browser-layout-effect");
+const usePsScrollRestoration = ({ elementRef, preventScrollReset, resetKey, restoreKey, }) => {
+    const keyRef = (0, react_1.useRef)(restoreKey);
+    const hasSavedRef = (0, react_1.useRef)(false);
+    const appliedKeyRef = (0, react_1.useRef)(undefined);
+    const appliedResetKeyRef = (0, react_1.useRef)(undefined);
+    const isRestoringRef = (0, react_1.useRef)(false);
+    const pendingRef = (0, react_1.useRef)(null);
+    const isEnabled = restoreKey !== undefined;
+    (0, react_1.useEffect)(() => {
+        if (!isEnabled ||
+            typeof window === 'undefined' ||
+            typeof history === 'undefined' ||
+            !('scrollRestoration' in history))
+            return;
+        const previous = history.scrollRestoration;
+        history.scrollRestoration = 'manual';
+        return () => {
+            history.scrollRestoration = previous;
+        };
+    }, [isEnabled]);
+    (0, use_ps_browser_layout_effect_1.usePsBrowserLayoutEffect)(() => {
+        keyRef.current = restoreKey;
+        if (typeof window === 'undefined')
+            return;
+        ps_scroll_storage_service_1.PsScrollStorageService.flush();
+        if (restoreKey === undefined)
+            return;
+        const element = elementRef === undefined ? null : elementRef.current;
+        const saved = ps_scroll_storage_service_1.PsScrollStorageService.read(ps_scroll_target_service_1.PsScrollTargetService.storageKey(element, restoreKey));
+        hasSavedRef.current = saved !== undefined;
+        if (saved === undefined)
+            return;
+        isRestoringRef.current = true;
+        const stop = ps_scroll_restore_service_1.PsScrollRestoreService.start(element, saved, () => {
+            isRestoringRef.current = false;
+        });
+        return () => {
+            stop();
+            isRestoringRef.current = false;
+        };
+    }, [restoreKey, elementRef]);
+    (0, use_ps_browser_layout_effect_1.usePsBrowserLayoutEffect)(() => {
+        const previousKey = appliedKeyRef.current;
+        const previousResetKey = appliedResetKeyRef.current;
+        appliedKeyRef.current = restoreKey;
+        appliedResetKeyRef.current = resetKey;
+        if (restoreKey === undefined || typeof window === 'undefined')
+            return;
+        const hasChanged = previousResetKey !== undefined && previousResetKey !== resetKey;
+        const isRestored = previousKey !== restoreKey && hasSavedRef.current;
+        if (!hasChanged || isRestored || preventScrollReset === true)
+            return;
+        ps_scroll_target_service_1.PsScrollTargetService.scrollTo(elementRef === undefined ? null : elementRef.current, 0);
+    }, [resetKey, restoreKey, elementRef, preventScrollReset]);
+    (0, react_1.useEffect)(() => {
+        if (!isEnabled || typeof window === 'undefined')
+            return;
+        const element = elementRef === undefined ? null : elementRef.current;
+        const target = ps_scroll_target_service_1.PsScrollTargetService.eventTarget(element);
+        let frame = 0;
+        const flushPending = () => {
+            const pending = pendingRef.current;
+            pendingRef.current = null;
+            if (pending !== null)
+                ps_scroll_storage_service_1.PsScrollStorageService.write(pending.key, pending.top);
+        };
+        const onScroll = () => {
+            const key = keyRef.current;
+            if (key === undefined || isRestoringRef.current)
+                return;
+            pendingRef.current = {
+                key: ps_scroll_target_service_1.PsScrollTargetService.storageKey(element, key),
+                top: ps_scroll_target_service_1.PsScrollTargetService.top(element),
+            };
+            if (frame !== 0)
+                return;
+            frame = window.requestAnimationFrame(() => {
+                frame = 0;
+                flushPending();
+            });
+        };
+        const onPageHide = () => {
+            const key = keyRef.current;
+            pendingRef.current = null;
+            if (key !== undefined && !isRestoringRef.current)
+                ps_scroll_storage_service_1.PsScrollStorageService.write(ps_scroll_target_service_1.PsScrollTargetService.storageKey(element, key), ps_scroll_target_service_1.PsScrollTargetService.top(element));
+            ps_scroll_storage_service_1.PsScrollStorageService.flush();
+        };
+        target.addEventListener('scroll', onScroll, { passive: true });
+        window.addEventListener('pagehide', onPageHide);
+        return () => {
+            target.removeEventListener('scroll', onScroll);
+            window.removeEventListener('pagehide', onPageHide);
+            window.cancelAnimationFrame(frame);
+            flushPending();
+        };
+    }, [isEnabled, elementRef]);
+};
+exports.usePsScrollRestoration = usePsScrollRestoration;

package/dist/index.d.ts

@@ -59,6 +59,7 @@ export * from './components/ps-skeleton';
 export * from './services/ps-scroll-lock-service';
 export * from './services/ps-skeleton-class-service';
 export * from './models/ps-skeleton-size';
+export * from './models/ps-skeleton-table-row';
 export * from './constants/ps-skeleton-shape';
 export * from './components/ps-skeleton-card';
 export * from './components/ps-skeleton-group';
@@ -192,3 +193,27 @@ export * from './components/ps-divider';
 export * from './models/ps-divider-orientation';
 export * from './components/ps-rating-display';
 export * from './constants/ps-rating-display-size';
+export * from './constants/ps-scroll-restoration-config';
+export * from './models/ps-scroll-offsets-data';
+export * from './models/ps-scroll-restoration-options';
+export * from './services/ps-scroll-storage-service';
+export * from './services/ps-scroll-target-service';
+export * from './services/ps-scroll-restore-service';
+export * from './hooks/use-ps-scroll-restoration';
+export * from './components/ps-scroll-restoration';
+export * from './hooks/use-ps-browser-layout-effect';
+export * from './models/ps-scroll-pending-save-data';
+export * from './constants/ps-flag-param-value';
+export * from './constants/ps-query-param-config';
+export * from './models/ps-search-params-set-options';
+export * from './models/ps-search-params-setter';
+export * from './models/ps-search-params-state';
+export * from './models/ps-choice-param-data';
+export * from './models/ps-flag-param-data';
+export * from './models/ps-choice-param-options';
+export * from './models/ps-flag-param-options';
+export * from './services/ps-query-param-service';
+export * from './hooks/use-ps-choice-param';
+export * from './hooks/use-ps-flag-param';
+export * from './constants/ps-rerender-config';
+export * from './hooks/use-ps-rerender-at';

package/dist/index.js

@@ -75,6 +75,7 @@ __exportStar(require("./components/ps-skeleton"), exports);
 __exportStar(require("./services/ps-scroll-lock-service"), exports);
 __exportStar(require("./services/ps-skeleton-class-service"), exports);
 __exportStar(require("./models/ps-skeleton-size"), exports);
+__exportStar(require("./models/ps-skeleton-table-row"), exports);
 __exportStar(require("./constants/ps-skeleton-shape"), exports);
 __exportStar(require("./components/ps-skeleton-card"), exports);
 __exportStar(require("./components/ps-skeleton-group"), exports);
@@ -208,3 +209,27 @@ __exportStar(require("./components/ps-divider"), exports);
 __exportStar(require("./models/ps-divider-orientation"), exports);
 __exportStar(require("./components/ps-rating-display"), exports);
 __exportStar(require("./constants/ps-rating-display-size"), exports);
+__exportStar(require("./constants/ps-scroll-restoration-config"), exports);
+__exportStar(require("./models/ps-scroll-offsets-data"), exports);
+__exportStar(require("./models/ps-scroll-restoration-options"), exports);
+__exportStar(require("./services/ps-scroll-storage-service"), exports);
+__exportStar(require("./services/ps-scroll-target-service"), exports);
+__exportStar(require("./services/ps-scroll-restore-service"), exports);
+__exportStar(require("./hooks/use-ps-scroll-restoration"), exports);
+__exportStar(require("./components/ps-scroll-restoration"), exports);
+__exportStar(require("./hooks/use-ps-browser-layout-effect"), exports);
+__exportStar(require("./models/ps-scroll-pending-save-data"), exports);
+__exportStar(require("./constants/ps-flag-param-value"), exports);
+__exportStar(require("./constants/ps-query-param-config"), exports);
+__exportStar(require("./models/ps-search-params-set-options"), exports);
+__exportStar(require("./models/ps-search-params-setter"), exports);
+__exportStar(require("./models/ps-search-params-state"), exports);
+__exportStar(require("./models/ps-choice-param-data"), exports);
+__exportStar(require("./models/ps-flag-param-data"), exports);
+__exportStar(require("./models/ps-choice-param-options"), exports);
+__exportStar(require("./models/ps-flag-param-options"), exports);
+__exportStar(require("./services/ps-query-param-service"), exports);
+__exportStar(require("./hooks/use-ps-choice-param"), exports);
+__exportStar(require("./hooks/use-ps-flag-param"), exports);
+__exportStar(require("./constants/ps-rerender-config"), exports);
+__exportStar(require("./hooks/use-ps-rerender-at"), exports);

package/dist/models/ps-choice-param-data.d.ts

@@ -0,0 +1,4 @@
+export interface PsChoiceParamData<Value extends string> {
+    onChange: (value: Value) => void;
+    value: Value;
+}

package/dist/models/ps-choice-param-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-choice-param-options.d.ts

@@ -0,0 +1,6 @@
+export interface PsChoiceParamOptions<Value extends string> {
+    fallback: Value;
+    name: string;
+    options: readonly Value[];
+    resetParams?: readonly string[];
+}

package/dist/models/ps-choice-param-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-flag-param-data.d.ts

@@ -0,0 +1,4 @@
+export interface PsFlagParamData {
+    isOn: boolean;
+    onChange: (isOn: boolean) => void;
+}

package/dist/models/ps-flag-param-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-flag-param-options.d.ts

@@ -0,0 +1,4 @@
+export interface PsFlagParamOptions {
+    name: string;
+    resetParams?: readonly string[];
+}

package/dist/models/ps-flag-param-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scroll-offsets-data.d.ts

@@ -0,0 +1 @@
+export type PsScrollOffsetsData = Record<string, number>;

package/dist/models/ps-scroll-offsets-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scroll-pending-save-data.d.ts

@@ -0,0 +1,4 @@
+export interface PsScrollPendingSaveData {
+    key: string;
+    top: number;
+}

package/dist/models/ps-scroll-pending-save-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scroll-restoration-options.d.ts

@@ -0,0 +1,7 @@
+import type { RefObject } from 'react';
+export interface PsScrollRestorationOptions {
+    elementRef?: RefObject<HTMLElement | null>;
+    preventScrollReset?: boolean;
+    resetKey?: string;
+    restoreKey?: string;
+}

package/dist/models/ps-scroll-restoration-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-search-params-set-options.d.ts

@@ -0,0 +1,4 @@
+export interface PsSearchParamsSetOptions {
+    preventScrollReset?: boolean;
+    replace?: boolean;
+}

package/dist/models/ps-search-params-set-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-search-params-setter.d.ts

@@ -0,0 +1,2 @@
+import type { PsSearchParamsSetOptions } from './ps-search-params-set-options';
+export type PsSearchParamsSetter = (update: (current: URLSearchParams) => URLSearchParams, options?: PsSearchParamsSetOptions) => void;

package/dist/models/ps-search-params-setter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-search-params-state.d.ts

@@ -0,0 +1,2 @@
+import type { PsSearchParamsSetter } from './ps-search-params-setter';
+export type PsSearchParamsState = readonly [URLSearchParams, PsSearchParamsSetter];

package/dist/models/ps-search-params-state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-skeleton-table-row.d.ts

@@ -0,0 +1,4 @@
+export interface PsSkeletonTableRow {
+    depth?: number;
+    isSection?: boolean;
+}

package/dist/models/ps-skeleton-table-row.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/ps-query-param-service.d.ts

@@ -0,0 +1,7 @@
+export declare class PsQueryParamService {
+    static choice<Value extends string>(value: string | null, options: readonly Value[], fallback: Value): Value;
+    static withChoice<Value extends string>(params: URLSearchParams, name: string, value: Value, fallback: Value, resetParams?: readonly string[]): URLSearchParams;
+    static flag(value: string | null): boolean;
+    static withFlag(params: URLSearchParams, name: string, isOn: boolean, resetParams?: readonly string[]): URLSearchParams;
+    private static cleared;
+}

package/dist/services/ps-query-param-service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsQueryParamService = void 0;
+const ps_flag_param_value_1 = require("../constants/ps-flag-param-value");
+class PsQueryParamService {
+    static choice(value, options, fallback) {
+        const match = options.find((option) => option === value);
+        return match === undefined ? fallback : match;
+    }
+    static withChoice(params, name, value, fallback, resetParams = []) {
+        const next = PsQueryParamService.cleared(params, resetParams);
+        if (value === fallback)
+            next.delete(name);
+        else
+            next.set(name, value);
+        return next;
+    }
+    static flag(value) {
+        return value === ps_flag_param_value_1.PsFlagParamValue.on;
+    }
+    static withFlag(params, name, isOn, resetParams = []) {
+        const next = PsQueryParamService.cleared(params, resetParams);
+        if (isOn)
+            next.set(name, ps_flag_param_value_1.PsFlagParamValue.on);
+        else
+            next.delete(name);
+        return next;
+    }
+    static cleared(params, resetParams) {
+        const next = new URLSearchParams(params);
+        for (const name of resetParams)
+            next.delete(name);
+        return next;
+    }
+}
+exports.PsQueryParamService = PsQueryParamService;

package/dist/services/ps-scroll-restore-service.d.ts

@@ -0,0 +1,3 @@
+export declare class PsScrollRestoreService {
+    static start(element: HTMLElement | null, top: number, onDone: () => void): () => void;
+}

package/dist/services/ps-scroll-restore-service.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScrollRestoreService = void 0;
+const ps_scroll_restoration_config_1 = require("../constants/ps-scroll-restoration-config");
+const ps_scroll_target_service_1 = require("./ps-scroll-target-service");
+class PsScrollRestoreService {
+    static start(element, top, onDone) {
+        let isDone = false;
+        let observer = null;
+        let mutations = null;
+        let timer = 0;
+        const finish = () => {
+            if (isDone)
+                return;
+            isDone = true;
+            window.clearTimeout(timer);
+            observer?.disconnect();
+            mutations?.disconnect();
+            for (const name of ps_scroll_restoration_config_1.PsScrollRestorationConfig.inputEvents)
+                window.removeEventListener(name, onInput, true);
+            onDone();
+        };
+        const onInput = () => finish();
+        const attempt = () => {
+            if (isDone)
+                return;
+            if (ps_scroll_target_service_1.PsScrollTargetService.maxTop(element) >= top - ps_scroll_restoration_config_1.PsScrollRestorationConfig.tolerancePx) {
+                ps_scroll_target_service_1.PsScrollTargetService.scrollTo(element, top);
+                finish();
+            }
+        };
+        for (const name of ps_scroll_restoration_config_1.PsScrollRestorationConfig.inputEvents)
+            window.addEventListener(name, onInput, { capture: true, passive: true });
+        timer = window.setTimeout(() => {
+            if (isDone)
+                return;
+            ps_scroll_target_service_1.PsScrollTargetService.scrollTo(element, top);
+            finish();
+        }, ps_scroll_restoration_config_1.PsScrollRestorationConfig.restoreTimeoutMs);
+        attempt();
+        if (!isDone && typeof MutationObserver !== 'undefined') {
+            mutations = new MutationObserver(attempt);
+            mutations.observe(element === null ? document.body : element, {
+                childList: true,
+                subtree: true,
+            });
+        }
+        if (!isDone && typeof ResizeObserver !== 'undefined') {
+            observer = new ResizeObserver(attempt);
+            for (const node of ps_scroll_target_service_1.PsScrollTargetService.observed(element))
+                observer.observe(node);
+        }
+        return finish;
+    }
+}
+exports.PsScrollRestoreService = PsScrollRestoreService;

package/dist/services/ps-scroll-storage-service.d.ts

@@ -0,0 +1,11 @@
+export declare class PsScrollStorageService {
+    private static offsets;
+    private static timer;
+    static read(key: string): number | undefined;
+    static write(key: string, top: number): void;
+    static flush(): void;
+    static reset(): void;
+    private static memory;
+    private static load;
+    private static isOffsets;
+}