@vorplex/web 0.0.8 → 0.0.11

package/dist/functions/class-names.function.d.ts

@@ -0,0 +1 @@
+export declare function classNames(...classes: (string | Record<string, boolean>)[]): string;

package/dist/functions/class-names.function.js

@@ -0,0 +1,14 @@
+export function classNames(...classes) {
+    let className = '';
+    for (const item of classes) {
+        if (typeof item === 'string') {
+            className = `${className} ${item}`.trim();
+        }
+        else {
+            for (const key in item) {
+                className = `${className} ${item[key] ? key : ''}`.trim();
+            }
+        }
+    }
+    return className;
+}

package/dist/functions/drag.function.d.ts

@@ -0,0 +1,26 @@
+export interface IDragOptions<T> {
+    event: DragEvent;
+    type: string;
+    data: T;
+    onDragStop?: () => void;
+}
+export declare class Drag {
+    private static listener;
+    static options: IDragOptions<any>;
+    private static targetElement;
+    static start<T>(options: IDragOptions<T>): void;
+    static get<T = any>(): {
+        options: IDragOptions<T>;
+        draggedElement: HTMLElement;
+        acceptedElement: HTMLElement;
+    };
+    static accepts<T>(options: {
+        event: DragEvent;
+        type: string;
+        condition?: (data: T, event: DragEvent) => boolean;
+        accepting?: (event: DragEvent, data: T) => () => void;
+        dropped: (data: T) => void;
+    }): boolean;
+    private static cleanupTarget;
+    private static cleanup;
+}

package/dist/functions/drag.function.js

@@ -0,0 +1,76 @@
+export class Drag {
+    static listener;
+    static options;
+    static targetElement;
+    static start(options) {
+        Drag.options = options;
+        Drag.targetElement = options.event.currentTarget;
+        options.event.currentTarget.addEventListener('dragend', () => {
+            options.onDragStop?.();
+            this.cleanup();
+        }, { once: true });
+    }
+    static get() {
+        return {
+            options: this.options,
+            draggedElement: this.targetElement,
+            acceptedElement: this.listener?.target
+        };
+    }
+    static accepts(options) {
+        if (!this.options)
+            return false;
+        if (options.event.currentTarget === this.targetElement)
+            return false;
+        if (Drag.options?.type !== options.type)
+            return false;
+        if (options.condition && !options.condition(Drag.options.data, options.event))
+            return;
+        const target = options.event.currentTarget;
+        if (this.listener?.target === target)
+            return false;
+        this.cleanupTarget();
+        let acceptingDispose;
+        this.listener = {
+            target,
+            drop: (e) => {
+                e.preventDefault();
+                options.dropped(this.options.data);
+                this.cleanup();
+            },
+            over: (event) => {
+                if (!this.options)
+                    return;
+                if (event.currentTarget === this.targetElement)
+                    return;
+                event.preventDefault();
+                acceptingDispose = options.accepting?.(event, Drag.options.data);
+            },
+            leave: (e) => {
+                const relatedTarget = e.relatedTarget;
+                if (e.currentTarget === target && (target instanceof Node && (!relatedTarget || !target.contains(relatedTarget)))) {
+                    this.cleanupTarget();
+                }
+            },
+            dispose: () => {
+                acceptingDispose?.();
+            }
+        };
+        target.addEventListener('drop', this.listener.drop, { once: true });
+        target.addEventListener('dragover', this.listener.over);
+        target.addEventListener('dragleave', this.listener.leave);
+        return true;
+    }
+    static cleanupTarget() {
+        this.listener?.target.removeEventListener('dragover', this.listener.over);
+        this.listener?.target.removeEventListener('drop', this.listener.drop);
+        this.listener?.target.removeEventListener('dragleave', this.listener.leave);
+        this.listener?.dispose?.();
+        this.listener = null;
+    }
+    static cleanup() {
+        this.cleanupTarget();
+        this.options = null;
+        this.targetElement = null;
+    }
+}

package/dist/functions/observe-element.function.d.ts

@@ -0,0 +1,3 @@
+export declare function observeElement(element: HTMLElement, observer: {
+    onTransform: (current: DOMRect, previous: DOMRect) => void;
+}): () => void;

package/dist/functions/observe-element.function.js

@@ -0,0 +1,18 @@
+import { $Value } from '@vorplex/core';
+export function observeElement(element, observer) {
+    let disposed = false;
+    let previousRect = element.getBoundingClientRect();
+    function observe() {
+        requestAnimationFrame(() => {
+            const rect = element.getBoundingClientRect();
+            if (!$Value.equals(rect, previousRect)) {
+                observer.onTransform(rect, previousRect);
+            }
+            previousRect = rect;
+            if (!disposed)
+                observe();
+        });
+    }
+    observe();
+    return () => { disposed = true; };
+}

package/dist/functions/on-mouse-drag.function.d.ts

@@ -0,0 +1,16 @@
+import { type Point } from '@vorplex/core';
+export interface MouseDragEvent {
+    mouseEvent: MouseEvent;
+    currentElement: HTMLElement;
+    delta: Point;
+    length: Point;
+}
+export interface MouseDragOptions {
+    event: MouseEvent;
+    snap?: number;
+    dragging?: (event: MouseDragEvent) => void;
+    dragged?: (delta: Point) => void;
+    resizing?: (event: MouseDragEvent) => void;
+    resized?: (delta: Point) => void;
+}
+export declare function onMouseDrag(options: MouseDragOptions): void;

package/dist/functions/on-mouse-drag.function.js

@@ -0,0 +1,61 @@
+import { $Number, $Point } from '@vorplex/core';
+export function onMouseDrag(options) {
+    options.event.stopPropagation();
+    const currentElement = options.event.currentTarget;
+    let action = 'drag';
+    if (options.resizing || options.resized) {
+        const rect = currentElement.getBoundingClientRect();
+        if (options.event.clientX === $Number.clamp(options.event.clientX, rect.left + rect.width - 15, rect.left + rect.width)) {
+            if (options.event.clientY === $Number.clamp(options.event.clientY, rect.top + rect.height - 15, rect.top + rect.height)) {
+                action = 'resize';
+            }
+        }
+    }
+    const snap = options.snap || 1;
+    const origin = $Point.create($Number.snap(options.event.clientX, snap), $Number.snap(options.event.clientY, snap));
+    let delta = origin;
+    const mouseMoveListener = (event) => {
+        const dragEvent = {
+            mouseEvent: options.event,
+            currentElement,
+            delta: {
+                x: $Number.snap(event.clientX - delta.x, snap),
+                y: $Number.snap(event.clientY - delta.y, snap),
+            },
+            length: {
+                x: $Number.snap(event.clientX - origin.x, snap),
+                y: $Number.snap(event.clientY - origin.y, snap),
+            },
+        };
+        if (dragEvent.length.x !== 0 || dragEvent.length.y !== 0) {
+            if (action === 'drag') {
+                options.dragging && options.dragging(dragEvent);
+            }
+            else {
+                options.resizing && options.resizing(dragEvent);
+            }
+        }
+        delta = $Point.create($Number.snap(event.clientX, snap), $Number.snap(event.clientY, snap));
+    };
+    const mouseUpListener = ({ clientX, clientY }) => {
+        document.removeEventListener('mousemove', mouseMoveListener, {
+            capture: true,
+        });
+        const delta = $Point.snap($Point.create(clientX - options.event.clientX, clientY - options.event.clientY), snap);
+        if (delta.x !== 0 || delta.y !== 0) {
+            if (action === 'drag') {
+                options.dragged && options.dragged(delta);
+            }
+            else {
+                options.resized && options.resized(delta);
+            }
+        }
+    };
+    document.addEventListener('mousemove', mouseMoveListener, {
+        capture: true,
+    });
+    document.addEventListener('mouseup', mouseUpListener, {
+        capture: true,
+        once: true,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './functions/class-names.function';
+export * from './functions/drag.function';
+export * from './functions/observe-element.function';
+export * from './functions/on-mouse-drag.function';
+export * from './utils/css.util';
+export * from './utils/element.util';
+export * from './utils/file-manager.util';
+export * from './utils/file-system.util';
+export * from './utils/indexed-db.util';
+export * from './utils/window-share.util';

package/dist/index.js

@@ -0,0 +1,11 @@
+// **/*.ts
+export * from './functions/class-names.function';
+export * from './functions/drag.function';
+export * from './functions/observe-element.function';
+export * from './functions/on-mouse-drag.function';
+export * from './utils/css.util';
+export * from './utils/element.util';
+export * from './utils/file-manager.util';
+export * from './utils/file-system.util';
+export * from './utils/indexed-db.util';
+export * from './utils/window-share.util';

package/dist/utils/css.util.d.ts

@@ -0,0 +1,12 @@
+export declare class $CSS {
+    private static state;
+    private static worker;
+    private static messages;
+    static init(): Promise<void>;
+    static compileScss(scss: string): Promise<string>;
+    static getRules(css: string): CSSStyleRule[];
+    static getStyleProperties(style: CSSStyleDeclaration): Record<string, string>;
+    static getProperties(css: string): Record<string, Record<string, string>> | null;
+    static fromProperties(style: Record<string, Record<string, string>>): string;
+    static toStyleAttribute(style: Record<string, string>): string;
+}

package/dist/utils/css.util.js

@@ -0,0 +1,92 @@
+import { $Id, $String, Emitter, State } from '@vorplex/core';
+export class $CSS {
+    static state = new State(null);
+    static worker;
+    static messages = new Emitter();
+    static async init() {
+        if ($CSS.state.value === null) {
+            $CSS.state.update('busy');
+            const response = await fetch('https://unpkg.com/sass.js/dist/sass.worker.js');
+            const content = await response.text();
+            const url = URL.createObjectURL(new Blob([content], { type: 'text/javascript' }));
+            $CSS.worker = new Worker(url);
+            $CSS.worker.addEventListener('message', (event) => $CSS.messages.emit(event), false);
+            $CSS.state.update('loaded');
+        }
+    }
+    static async compileScss(scss) {
+        $CSS.init();
+        await $CSS.state.until((state) => state.value === 'loaded');
+        const id = $Id.uuid();
+        $CSS.worker.postMessage({
+            id,
+            command: 'compile',
+            args: [scss],
+        });
+        const message = await $CSS.messages.until((message) => message.data.id === id);
+        return message.data.result.text;
+    }
+    static getRules(css) {
+        const sheet = new CSSStyleSheet();
+        const rules = css
+            .split('}')
+            .map((rule) => rule.trim())
+            .filter((rule) => rule)
+            .map((rule) => rule + '}');
+        for (const rule of rules) {
+            try {
+                sheet.insertRule(rule);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+        return Array.from(sheet.rules).filter((rule) => rule?.selectorText);
+    }
+    static getStyleProperties(style) {
+        const properties = {};
+        for (let i = 0; i < style.length; i++) {
+            const property = style.item(i);
+            let value = style.getPropertyValue(property).trim();
+            if (value.startsWith('url(')) {
+                value = value.replace('~', window.location.origin + window.location.pathname);
+                if (value.indexOf('^') < 6) {
+                    value = value.replace('^', '');
+                }
+            }
+            properties[$String.camelCase(property)] = value;
+        }
+        return properties;
+    }
+    static getProperties(css) {
+        try {
+            const rules = $CSS.getRules(css);
+            const properties = {};
+            for (const rule of rules) {
+                if (!rule.selectorText.startsWith('@')) {
+                    properties[rule.selectorText] = $CSS.getStyleProperties(rule.style);
+                }
+            }
+            return properties;
+        }
+        catch {
+            return null;
+        }
+    }
+    static fromProperties(style) {
+        let css = '';
+        for (const selector of Object.keys(style).reverse()) {
+            css += `${selector} {\n${Object.keys(style[selector])
+                .map((property) => `\t${property}: ${style[selector][property]};`)
+                .join('\n')}\n}\n`;
+        }
+        return css;
+    }
+    static toStyleAttribute(style) {
+        let css = '';
+        for (const property in style) {
+            css += `${property}: ${style[property]};`;
+        }
+        return css;
+    }
+}

package/dist/utils/element.util.d.ts

@@ -0,0 +1,20 @@
+import { type Point } from '@vorplex/core';
+export declare class $Element {
+    static getRelativePoint(element: HTMLElement, position: 'top' | 'right' | 'bottom' | 'left', offset?: number): Point;
+    static getBounds(element: HTMLElement): {
+        width: number;
+        height: number;
+        topLeft: Point;
+        topCenter: Point;
+        topRight: Point;
+        rightCenter: Point;
+        bottomLeft: Point;
+        bottomCenter: Point;
+        bottomRight: Point;
+        leftCenter: Point;
+    };
+    static addEventListener<T extends Document | HTMLElement, TT extends T extends Document ? DocumentEventMap : HTMLElementEventMap, TTT extends string & keyof TT>(element: T, type: TTT, listener: (event: TT[TTT], listener: {
+        remove: () => void;
+    }) => any, options?: boolean | AddEventListenerOptions): () => void;
+    static getEventProperties(elementTag: string): string[];
+}

package/dist/utils/element.util.js

@@ -0,0 +1,57 @@
+import { $Point } from '@vorplex/core';
+export class $Element {
+    static getRelativePoint(element, position, offset = 0) {
+        const point = $Point.create();
+        if (element) {
+            const rect = element.getBoundingClientRect();
+            if (position === 'top') {
+                point.x = rect.x + rect.width / 2;
+                point.y = rect.y - offset;
+            }
+            else if (position === 'right') {
+                point.x = rect.x + rect.width + offset;
+                point.y = rect.y + rect.height / 2;
+            }
+            else if (position === 'bottom') {
+                point.x = rect.x + rect.width / 2;
+                point.y = rect.y + rect.height + offset;
+            }
+            else if (position === 'left') {
+                point.x = rect.x - offset;
+                point.y = rect.y + rect.height / 2;
+            }
+        }
+        return point;
+    }
+    static getBounds(element) {
+        const rect = element.getBoundingClientRect();
+        return {
+            width: rect.width,
+            height: rect.height,
+            topLeft: $Point.create(rect.x, rect.y),
+            topCenter: $Point.create(rect.x + rect.width / 2, rect.y),
+            topRight: $Point.create(rect.x + rect.width, rect.y),
+            rightCenter: $Point.create(rect.x + rect.width, rect.y + rect.height / 2),
+            bottomLeft: $Point.create(rect.x, rect.y + rect.height),
+            bottomCenter: $Point.create(rect.x + rect.width / 2, rect.y + rect.height),
+            bottomRight: $Point.create(rect.x + rect.width, rect.y + rect.height),
+            leftCenter: $Point.create(rect.x, rect.y + rect.height / 2),
+        };
+    }
+    static addEventListener(element, type, listener, options) {
+        const remove = () => element.removeEventListener(type, handler);
+        const handler = event => listener(event, { remove });
+        element.addEventListener(type, handler, options);
+        return remove;
+    }
+    static getEventProperties(elementTag) {
+        const target = document.createElement(elementTag);
+        const events = [];
+        for (const key in target) {
+            if (key.startsWith('on') && key.length > 2) {
+                events.push(key);
+            }
+        }
+        return events.sort();
+    }
+}

package/dist/utils/file-manager.util.d.ts

@@ -0,0 +1,12 @@
+export type FileDialogOptions = {
+    mimeTypes?: string[];
+    multiple?: boolean;
+};
+export declare class $FileManager {
+    static showDialog(options?: Partial<FileDialogOptions>): Promise<File[]>;
+    static readText(file: File): Promise<string>;
+    static readBase64(file: File): Promise<string>;
+    static readBytes(file: File): Promise<ArrayBuffer>;
+    static toObjectUrl(file: File): Promise<string>;
+    static download(file: string, content: Blob | string): void;
+}

package/dist/utils/file-manager.util.js

@@ -0,0 +1,50 @@
+export class $FileManager {
+    static showDialog(options) {
+        return new Promise((resolve) => {
+            const input = document.createElement('input');
+            input.type = 'file';
+            if (options) {
+                input.accept = options.mimeTypes?.join(',') ?? '';
+                input.multiple = !!options.multiple;
+            }
+            input.click();
+            input.onchange = (event) => resolve(Array.from(event.target.files));
+        });
+    }
+    static readText(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onerror = () => reject();
+            reader.onload = () => resolve(reader.result);
+            reader.readAsText(file);
+        });
+    }
+    static readBase64(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onerror = () => reject();
+            reader.onloadend = () => resolve(reader.result);
+            reader.readAsDataURL(file);
+        });
+    }
+    static readBytes(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onerror = () => reject();
+            reader.onload = () => resolve(reader.result);
+            reader.readAsArrayBuffer(file);
+        });
+    }
+    static async toObjectUrl(file) {
+        return URL.createObjectURL(file);
+    }
+    static download(file, content) {
+        const downloadLink = document.createElement('a');
+        const blob = content instanceof Blob ? content : new Blob([content], { type: 'text/plain' });
+        downloadLink.href = URL.createObjectURL(blob);
+        downloadLink.setAttribute('download', file);
+        downloadLink.click();
+        downloadLink.remove();
+        URL.revokeObjectURL(downloadLink.href);
+    }
+}

package/dist/utils/file-system.util.d.ts

@@ -0,0 +1,20 @@
+declare global {
+    interface Window {
+        showDirectoryPicker: () => Promise<FileSystemDirectoryHandle>;
+    }
+    function showDirectoryPicker(): Promise<FileSystemDirectoryHandle>;
+}
+export declare class $FileSystem {
+    private static handle;
+    static open(): Promise<FileSystemDirectoryHandle>;
+    static getDirectoryHandle(path: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemDirectoryHandle>;
+    static getFileHandle(path: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemFileHandle>;
+    static write(path: string, content: FileSystemWriteChunkType | ReadableStream): Promise<void>;
+    static read(path: string): Promise<File>;
+    static createFolder(path: string): Promise<void>;
+    static delete(path: string): Promise<void>;
+}

package/dist/utils/file-system.util.js

@@ -0,0 +1,63 @@
+import { $Path } from '@vorplex/core';
+export class $FileSystem {
+    static handle;
+    static async open() {
+        $FileSystem.handle = await window.showDirectoryPicker();
+        return $FileSystem.handle;
+    }
+    static async getDirectoryHandle(path, options) {
+        const paths = $Path.absolute(path).split('/');
+        if (paths.length === 0)
+            return $FileSystem.handle;
+        let target = paths.shift();
+        let handle = $FileSystem.handle ?? (await $FileSystem.open());
+        while (target) {
+            handle = await handle.getDirectoryHandle(target, options);
+            target = paths.shift();
+        }
+        return handle;
+    }
+    static async getFileHandle(path, options) {
+        const paths = $Path.absolute(path).split('/');
+        if (paths.length === 0)
+            return null;
+        let target = paths.shift();
+        let handle = $FileSystem.handle ?? (await $FileSystem.open());
+        while (target) {
+            if (paths.length > 0)
+                handle = await handle.getDirectoryHandle(target, options);
+            else
+                return await handle.getFileHandle(target, options);
+            target = paths.shift();
+        }
+    }
+    static async write(path, content) {
+        const handle = await $FileSystem.getFileHandle(path, { create: true });
+        const writable = await handle.createWritable();
+        if (content instanceof ReadableStream) {
+            const reader = content.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                await writable.write(value);
+            }
+            reader.releaseLock();
+        }
+        else {
+            await writable.write(content);
+        }
+        await writable.close();
+    }
+    static async read(path) {
+        const handle = await $FileSystem.getFileHandle(path);
+        return await handle.getFile();
+    }
+    static async createFolder(path) {
+        await $FileSystem.getDirectoryHandle(path, { create: true });
+    }
+    static async delete(path) {
+        const directory = await $FileSystem.getDirectoryHandle($Path.getDirectory(path));
+        await directory.removeEntry($Path.entryName(path), { recursive: true });
+    }
+}

package/dist/utils/indexed-db.util.d.ts

@@ -0,0 +1,12 @@
+export declare class IndexedDB {
+    static getDatabaseInfo(name: string): Promise<IDBDatabaseInfo | undefined>;
+    static openDatabase(name: string, version?: number): Promise<IDBDatabase & Disposable>;
+    static getDatabaseStores(name: string): Promise<string[]>;
+    static createDatabaseStore(databaseName: string, storeName: string): Promise<void>;
+    static openStore(databaseName: string, storeName: string, mode?: IDBTransactionMode): Promise<IDBObjectStore & Disposable>;
+    static set(databaseName: string, storeName: string, key: string, value: any): Promise<void>;
+    static get<T = any>(databaseName: string, storeName: string, key: IDBValidKey | IDBKeyRange): Promise<T | null>;
+    static getAllKeys(databaseName: string, storeName: string): Promise<string[] | null>;
+    static getAll<T = any>(databaseName: string, storeName: string, key?: IDBValidKey | IDBKeyRange): Promise<T[] | null>;
+    static clear(databaseName: string, storeName: string): Promise<void>;
+}

package/dist/utils/indexed-db.util.js

@@ -0,0 +1,94 @@
+export class IndexedDB {
+    static async getDatabaseInfo(name) {
+        const databases = await indexedDB.databases();
+        return databases.find((database) => database.name === name);
+    }
+    static async openDatabase(name, version) {
+        const db = await new Promise((resolve, reject) => {
+            const request = indexedDB.open(name, version);
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = (event) => reject(event.target.error);
+        });
+        return Object.assign(db, {
+            [Symbol.dispose]() {
+                db.close();
+            },
+        });
+    }
+    static async getDatabaseStores(name) {
+        using database = await IndexedDB.openDatabase(name);
+        return Array.from(database.objectStoreNames);
+    }
+    static async createDatabaseStore(databaseName, storeName) {
+        const existingStores = await IndexedDB.getDatabaseStores(databaseName);
+        if (existingStores.find((store) => store === storeName))
+            return;
+        const databaseInfo = await IndexedDB.getDatabaseInfo(databaseName);
+        const currentVersion = databaseInfo?.version || 1;
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(databaseName, currentVersion + 1);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName);
+                }
+            };
+            request.onsuccess = () => {
+                request.result.close();
+                resolve();
+            };
+            request.onerror = (event) => reject(event.target.error);
+        });
+    }
+    static async openStore(databaseName, storeName, mode = 'readwrite') {
+        await IndexedDB.createDatabaseStore(databaseName, storeName);
+        const db = await IndexedDB.openDatabase(databaseName);
+        const transaction = db.transaction(storeName, mode);
+        const objectStore = transaction.objectStore(storeName);
+        return Object.assign(objectStore, {
+            [Symbol.dispose]() {
+                db.close();
+            },
+        });
+    }
+    static async set(databaseName, storeName, key, value) {
+        using store = await IndexedDB.openStore(databaseName, storeName);
+        const request = store.put(value, key);
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve();
+            request.onerror = (event) => reject(event.target.error);
+        });
+    }
+    static async get(databaseName, storeName, key) {
+        using store = await IndexedDB.openStore(databaseName, storeName, 'readonly');
+        const request = store.get(key);
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result ?? null);
+            request.onerror = (event) => reject(event.target.error);
+        });
+    }
+    static async getAllKeys(databaseName, storeName) {
+        using store = await IndexedDB.openStore(databaseName, storeName, 'readonly');
+        const request = store.getAllKeys();
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result ?? null);
+            request.onerror = (event) => reject(event.target.error);
+        });
+    }
+    static async getAll(databaseName, storeName, key) {
+        using store = await IndexedDB.openStore(databaseName, storeName, 'readonly');
+        const request = store.getAll(key);
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result ?? null);
+            request.onerror = (event) => reject(event.target.error);
+        });
+    }
+    static async clear(databaseName, storeName) {
+        using store = await IndexedDB.openStore(databaseName, storeName);
+        return new Promise((resolve, reject) => {
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = (event) => reject(event.target.error);
+        });
+    }
+}

package/dist/utils/window-share.util.d.ts

@@ -0,0 +1,4 @@
+export declare class $WindowShare {
+    static share(win: Window, key: string, value: any): void;
+    static get<T = any>(key: string): T;
+}

package/dist/utils/window-share.util.js

@@ -0,0 +1,9 @@
+export class $WindowShare {
+    static share(win, key, value) {
+        win['shared'] ??= {};
+        win['shared'][key] = value;
+    }
+    static get(key) {
+        return window['shared']?.[key];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorplex/web",
-  "version": "0.0.8",
+  "version": "0.0.11",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -16,7 +16,7 @@
   "main": "./dist/index.js",
   "dependencies": {
     "tslib": "^2.8.1",
-    "@vorplex/core": "0.0.8"
+    "@vorplex/core": "0.0.11"
   },
   "devDependencies": {
     "@types/jest": "^29.5.2",