@blueprintui/cli 0.0.4 → 0.0.7

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/state-expanded.controller.js

@@ -0,0 +1,29 @@
+import { attachInternals } from '../utils/a11y.js';
+export function stateExpanded() {
+    return (target) => target.addInitializer((instance) => new StateExpandedController(instance));
+}
+export class StateExpandedController {
+    host;
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        attachInternals(this.host);
+    }
+    hostUpdated() {
+        if (this.host.expanded !== null && this.host.expanded !== undefined) {
+            this.host._internals.ariaExpanded = `${this.host.expanded}`;
+        }
+        if (this.host.expanded) {
+            this.host._internals.states.add('--expanded');
+        }
+        else {
+            this.host._internals.states.delete('--expanded');
+        }
+        if (this.host.readonly) {
+            this.host._internals.ariaExpanded = null;
+            this.host._internals.states.delete('--expanded');
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/state-pressed.controller.d.ts

@@ -0,0 +1,13 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export declare type AriaPressed = ReactiveElement & {
+    pressed: boolean;
+    readonly?: boolean;
+    _internals?: ElementInternals;
+};
+export declare function statePressed<T extends AriaPressed>(): ClassDecorator;
+export declare class StatePressedController<T extends AriaPressed> implements ReactiveController {
+    private host;
+    constructor(host: T);
+    hostConnected(): void;
+    hostUpdated(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/state-pressed.controller.js

@@ -0,0 +1,29 @@
+import { attachInternals } from '../utils/a11y.js';
+export function statePressed() {
+    return (target) => target.addInitializer((instance) => new StatePressedController(instance));
+}
+export class StatePressedController {
+    host;
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        attachInternals(this.host);
+    }
+    hostUpdated() {
+        if (this.host.pressed !== null && this.host.pressed !== undefined) {
+            this.host._internals.ariaPressed = `${this.host.pressed}`;
+        }
+        if (this.host.pressed) {
+            this.host._internals.states.add('--pressed');
+        }
+        else {
+            this.host._internals.states.delete('--pressed');
+        }
+        if (this.host.readonly) {
+            this.host._internals.ariaPressed = null;
+            this.host._internals.states.delete('--pressed');
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-anchor.controller.d.ts

@@ -0,0 +1,12 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export interface Anchor extends ReactiveElement {
+    disabled: boolean;
+    readonly: boolean;
+}
+export declare function typeAnchor<T extends Anchor>(): ClassDecorator;
+export declare class TypeAnchorController<T extends Anchor> implements ReactiveController {
+    #private;
+    private host;
+    constructor(host: T);
+    hostConnected(): Promise<void>;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-anchor.controller.js

@@ -0,0 +1,25 @@
+export function typeAnchor() {
+    return (target) => target.addInitializer((instance) => new TypeAnchorController(instance));
+}
+export class TypeAnchorController {
+    host;
+    get #anchor() {
+        const slottedAnchor = this.host.querySelector('a');
+        return slottedAnchor ? slottedAnchor : this.host.shadowRoot.querySelector('a');
+    }
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    async hostConnected() {
+        await this.host.updateComplete;
+        if (this.#anchor) {
+            this.host.readonly = true;
+        }
+        this.#anchor?.addEventListener('click', e => {
+            if (this.host.disabled) {
+                e.preventDefault();
+            }
+        });
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-button.controller.d.ts

@@ -0,0 +1,16 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export interface AriaButton extends ReactiveElement {
+    readonly: boolean;
+    disabled: boolean;
+    _internals?: ElementInternals;
+}
+/**
+ * Provides nessesary attributes for indicating a non-button element as an accessible button type.
+ */
+export declare function typeButton<T extends AriaButton>(): ClassDecorator;
+export declare class TypeButtonController<T extends AriaButton> implements ReactiveController {
+    private host;
+    constructor(host: T);
+    hostConnected(): void;
+    hostUpdated(): Promise<void>;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-button.controller.js

@@ -0,0 +1,30 @@
+import { attachInternals } from '../utils/a11y.js';
+/**
+ * Provides nessesary attributes for indicating a non-button element as an accessible button type.
+ */
+export function typeButton() {
+    return (target) => target.addInitializer((instance) => new TypeButtonController(instance));
+}
+export class TypeButtonController {
+    host;
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        attachInternals(this.host);
+        this.host.tabIndex = 0; // element can be focused synchronously
+    }
+    async hostUpdated() {
+        await this.host.updateComplete;
+        if (!this.host._internals.role) {
+            this.host._internals.role = 'button';
+        }
+        this.host.tabIndex = !this.host.disabled ? 0 : -1;
+        if (this.host.readonly) {
+            this.host._internals.role = null;
+            this.host.tabIndex = null;
+            this.host.removeAttribute('tabindex');
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-dialog.controller.d.ts

@@ -0,0 +1,22 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export interface HTMLDialog extends HTMLElement {
+    showModal?: () => void;
+    close?: () => void;
+}
+export interface Dialog extends ReactiveElement {
+    dialog: HTMLDialog;
+    dismissible: boolean;
+    static?: boolean;
+}
+/**
+ * Provides nessesary API for dialog type elements
+ */
+export declare function typeDialog<T extends Dialog>(): ClassDecorator;
+export declare class TypeDialogController<T extends Dialog> implements ReactiveController {
+    #private;
+    private host;
+    constructor(host: T);
+    hostConnected(): Promise<void>;
+    hostDisconnected(): void;
+    close(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-dialog.controller.js

@@ -0,0 +1,69 @@
+import { listenForAttributeChange } from '../utils/events';
+/**
+ * Provides nessesary API for dialog type elements
+ */
+export function typeDialog() {
+    return (target) => target.addInitializer((instance) => {
+        if (!instance.dialogController) {
+            Object.defineProperty(instance, 'dialogController', {
+                value: new TypeDialogController(instance),
+                writable: false
+            });
+        }
+        return instance.dialogController;
+    });
+}
+export class TypeDialogController {
+    host;
+    #observers = [];
+    #hidden = false;
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    async hostConnected() {
+        await this.host.updateComplete;
+        this.host.dialog?.addEventListener('click', (e) => this.#lightDismiss(e));
+        this.host.dialog?.addEventListener('cancel', (e) => this.#escape(e));
+        this.host.dialog?.addEventListener('close', (e) => this.#escape(e));
+        this.#toggleDialog();
+        this.#listenForHiddenChange();
+    }
+    hostDisconnected() {
+        this.#observers.forEach(observer => observer.disconnect());
+    }
+    close() {
+        if (this.host.dismissible) {
+            this.host.dispatchEvent(new CustomEvent('close'));
+        }
+    }
+    #listenForHiddenChange() {
+        this.#observers.push(listenForAttributeChange(this.host, 'hidden', () => {
+            if (this.#hidden !== this.host.hidden) {
+                this.#toggleDialog();
+            }
+        }));
+    }
+    #toggleDialog() {
+        if (!this.host.static) {
+            if (this.host.hidden) {
+                this.host.dialog?.close();
+            }
+            else {
+                this.host.dialog?.showModal();
+            }
+            this.#hidden = this.host.hidden;
+            this.host.dialog.hidden = this.host.hidden;
+        }
+    }
+    #escape(event) {
+        event.preventDefault();
+        this.close();
+    }
+    #lightDismiss(event) {
+        const tag = event.target.nodeName;
+        if (tag === 'DIALOG') {
+            this.close();
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-popup.controller.d.ts

@@ -0,0 +1,24 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export declare type Alignment = 'start' | 'end';
+export declare type Side = 'top' | 'right' | 'bottom' | 'left';
+export declare type AlignedPosition = `${Side}-${Alignment}`;
+export declare type Position = Side | AlignedPosition | 'center';
+export interface Popup extends ReactiveElement {
+    popup: HTMLElement;
+    auto?: boolean;
+    anchor?: HTMLElement | string;
+    position?: Position;
+    arrow?: HTMLElement;
+}
+export interface PopupConfig {
+    position?: Position;
+}
+export declare function typePopup<T extends Popup>(): ClassDecorator;
+export declare class TypePopupController<T extends Popup> implements ReactiveController {
+    #private;
+    private host;
+    middleware: any[];
+    constructor(host: T);
+    hostUpdated(): Promise<void>;
+    hostDisconnected(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-popup.controller.js

@@ -0,0 +1,88 @@
+import { computePosition, autoUpdate, autoPlacement } from '@floating-ui/dom';
+export function typePopup() {
+    return (target) => target.addInitializer((instance) => {
+        if (!instance.popupController) {
+            Object.defineProperty(instance, 'popupController', {
+                value: new TypePopupController(instance),
+                writable: false
+            });
+        }
+        return instance.popupController;
+    });
+}
+export class TypePopupController {
+    host;
+    middleware = [];
+    #hidden = false;
+    #subscription;
+    get #popup() {
+        return this.host.popup ? this.host.popup : this.host;
+    }
+    get #anchor() {
+        const isElement = typeof this.host.anchor === 'object' && this.host.anchor.nodeType !== undefined;
+        return isElement ? this.host.anchor : this.#root.querySelector(`#${this.host.anchor}`);
+    }
+    get #root() {
+        const root = this.host.parentNode;
+        return root.shadowRoot ? root.shadowRoot : root;
+    }
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+        window.process = { env: { NODE_ENV: 'production' } }; // workaround for floating-ui issue
+    }
+    async hostUpdated() {
+        await this.host.updateComplete;
+        if (this.host.anchor && !this.#subscription) {
+            this.#subscription = autoUpdate(this.#anchor, this.#popup, () => this.#computePosition());
+        }
+        if ((!this.host.hidden && this.host.anchor) && (this.#hidden !== this.host.hidden)) {
+            this.#computePosition();
+        }
+    }
+    hostDisconnected() {
+        this.#subscription();
+    }
+    async #computePosition() {
+        if (!this.host.hidden && this.host.position !== 'center') {
+            const config = {
+                placement: this.host.position,
+                middleware: [
+                    ...this.middleware,
+                    ...this.host.auto ? [autoPlacement()] : [],
+                ]
+            };
+            const position = await computePosition(this.#anchor, this.#popup, config);
+            this.host.position = position.placement;
+            if (position.strategy === 'absolute') {
+                this.#setPopoverPosition(position.x, position.y, position.strategy);
+            }
+            if (position.middlewareData.arrow) {
+                this.#setArrowPosition(position.middlewareData.arrow.x, position.middlewareData.arrow.y, position.placement);
+            }
+        }
+    }
+    #setPopoverPosition(x, y, strategy) {
+        Object.assign(this.#popup.style, {
+            position: strategy,
+            left: `${x}px`,
+            top: `${y}px`,
+            margin: 0
+        });
+    }
+    #setArrowPosition(x, y, placement) {
+        const staticSide = {
+            top: 'bottom',
+            right: 'left',
+            bottom: 'top',
+            left: 'right',
+        }[placement.split('-')[0]];
+        Object.assign(this.host.arrow.style, {
+            left: x !== null ? `${x}px` : '',
+            top: y !== null ? `${y}px` : '',
+            right: '',
+            bottom: '',
+            [staticSide]: '-10px',
+        });
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-submit.controller.d.ts

@@ -0,0 +1,15 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export declare type ButtonSubmit = ReactiveElement & HTMLElement & {
+    name: string;
+    value: string;
+    disabled: boolean;
+    type: 'button' | 'submit';
+    readonly: boolean;
+};
+export declare function typeSubmit<T extends ButtonSubmit>(): ClassDecorator;
+export declare class TypeSubmitController<T extends ButtonSubmit> implements ReactiveController {
+    #private;
+    private host;
+    constructor(host: T);
+    hostUpdated(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/controllers/type-submit.controller.js

@@ -0,0 +1,64 @@
+import { stopEvent, onKeys } from '../utils/events.js';
+export function typeSubmit() {
+    return (target) => target.addInitializer((instance) => new TypeSubmitController(instance));
+}
+export class TypeSubmitController {
+    host;
+    #button;
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostUpdated() {
+        this.#setButtonType();
+        this.#setupSubmitButton();
+        this.#setupNativeButtonBehavior();
+    }
+    #setButtonType() {
+        if (!this.host.type && this.host.closest('form')) {
+            this.host.type = 'submit';
+        }
+    }
+    #setupSubmitButton() {
+        if (!this.#button) {
+            this.#button = document.createElement('button');
+            this.#button.inert = true;
+        }
+        this.#button.value = this.host.value;
+        this.#button.name = this.host.name;
+        this.#button.type = this.host.type;
+    }
+    #setupNativeButtonBehavior() {
+        if (this.host.readonly || this.host.disabled) {
+            this.host.removeEventListener('click', this.#triggerNativeButtonBehavior.bind(this));
+            this.host.removeEventListener('keyup', this.#emulateKeyBoardEventBehavior.bind(this));
+        }
+        else {
+            this.host.addEventListener('click', this.#triggerNativeButtonBehavior.bind(this));
+            this.host.addEventListener('keyup', this.#emulateKeyBoardEventBehavior.bind(this));
+        }
+    }
+    #emulateKeyBoardEventBehavior(event) {
+        onKeys(['Enter', 'Space'], event, () => {
+            // When submitting forms with Enter key, the default submit button receives a click event from the form
+            if (this.host.type === 'submit') {
+                this.#triggerNativeButtonBehavior(event);
+            }
+            else {
+                this.host.click();
+            }
+            stopEvent(event);
+        });
+    }
+    /** hidden button enables native "submit" events within a form element */
+    #triggerNativeButtonBehavior(event) {
+        if (this.host.disabled) {
+            stopEvent(event);
+        }
+        else if (!event.defaultPrevented) {
+            this.host.appendChild(this.#button);
+            this.#button.dispatchEvent(new MouseEvent('click', { relatedTarget: this.host, composed: true }));
+            this.#button.remove();
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/index.d.ts

@@ -0,0 +1,38 @@
+export * from './styles/styles.js';
+export * from './base/button.js';
+export * from './controllers/aria-group.controller.js';
+export * from './controllers/aria-menu.controller.js';
+export * from './controllers/aria-multiselectable.controller.js';
+export * from './controllers/aria-navigation.controller.js';
+export * from './controllers/aria-region.controller.js';
+export * from './controllers/i18n.controller.js';
+export * from './controllers/interaction-range-selection.controller.js';
+export * from './controllers/interaction-responsive.controller.js';
+export * from './controllers/interaction-scroll-visibility.controller.js';
+export * from './controllers/key-grid.controller.js';
+export * from './controllers/key-list.controller.js';
+export * from './controllers/state-active.controller.js';
+export * from './controllers/state-disabled.controller.js';
+export * from './controllers/state-expanded.controller.js';
+export * from './controllers/state-pressed.controller.js';
+export * from './controllers/type-anchor.controller.js';
+export * from './controllers/type-button.controller.js';
+export * from './controllers/type-dialog.controller.js';
+export * from './controllers/type-popup.controller.js';
+export * from './controllers/type-submit.controller.js';
+export * from './interfaces/interfaces.js';
+export * from './services/global.service.js';
+export * from './services/i18n.service.js';
+export * from './utils/a11y.js';
+export * from './utils/array.js';
+export * from './utils/dom.js';
+export * from './utils/events.js';
+export * from './utils/event-subject.js';
+export * from './utils/focus.js';
+export * from './utils/i18n.js';
+export * from './utils/lit.js';
+export * from './utils/keynav.js';
+export * from './utils/responsive.js';
+export * from './utils/string.js';
+export * from './utils/time.js';
+export * from './utils/traversal.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/index.js

@@ -0,0 +1,38 @@
+export * from './styles/styles.js';
+export * from './base/button.js';
+export * from './controllers/aria-group.controller.js';
+export * from './controllers/aria-menu.controller.js';
+export * from './controllers/aria-multiselectable.controller.js';
+export * from './controllers/aria-navigation.controller.js';
+export * from './controllers/aria-region.controller.js';
+export * from './controllers/i18n.controller.js';
+export * from './controllers/interaction-range-selection.controller.js';
+export * from './controllers/interaction-responsive.controller.js';
+export * from './controllers/interaction-scroll-visibility.controller.js';
+export * from './controllers/key-grid.controller.js';
+export * from './controllers/key-list.controller.js';
+export * from './controllers/state-active.controller.js';
+export * from './controllers/state-disabled.controller.js';
+export * from './controllers/state-expanded.controller.js';
+export * from './controllers/state-pressed.controller.js';
+export * from './controllers/type-anchor.controller.js';
+export * from './controllers/type-button.controller.js';
+export * from './controllers/type-dialog.controller.js';
+export * from './controllers/type-popup.controller.js';
+export * from './controllers/type-submit.controller.js';
+export * from './interfaces/interfaces.js';
+export * from './services/global.service.js';
+export * from './services/i18n.service.js';
+export * from './utils/a11y.js';
+export * from './utils/array.js';
+export * from './utils/dom.js';
+export * from './utils/events.js';
+export * from './utils/event-subject.js';
+export * from './utils/focus.js';
+export * from './utils/i18n.js';
+export * from './utils/lit.js';
+export * from './utils/keynav.js';
+export * from './utils/responsive.js';
+export * from './utils/string.js';
+export * from './utils/time.js';
+export * from './utils/traversal.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/interfaces/interfaces.d.ts

@@ -0,0 +1 @@
+export declare type Directions = 'up' | 'down' | 'left' | 'right';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/interfaces/interfaces.js

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

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/services/global.service.d.ts

@@ -0,0 +1,24 @@
+declare global {
+    interface Window {
+        blueprintuiGlobal: GlobalState;
+        blueprintuiGlobalChannelId: string;
+        structuredClone: <T>(value: T, transferables?: any) => T;
+    }
+}
+export interface BpState {
+    environment: {
+        production: boolean;
+    };
+    i18nRegistry: Readonly<Record<string, any>>;
+    iconRegistry: Readonly<Record<string, unknown>>;
+}
+export declare class GlobalState {
+    #private;
+    readonly stateUpdate: import("../utils/event-subject.js").BroadcastObservable<{
+        type: string;
+        state: Partial<BpState>;
+    }>;
+    get state(): BpState;
+    dispatch(type: string, state: Partial<BpState>): void;
+}
+export declare const GlobalStateService: GlobalState;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/services/global.service.js

@@ -0,0 +1,20 @@
+import { BroadcastSubject } from '../utils/event-subject.js';
+import { mergeObjects } from '../utils/traversal.js';
+export class GlobalState {
+    #stateUpdate = new BroadcastSubject();
+    #state = {
+        environment: { production: false },
+        i18nRegistry: {},
+        iconRegistry: {},
+    };
+    stateUpdate = this.#stateUpdate.toEventObservable();
+    get state() {
+        return this.#state;
+    }
+    dispatch(type, state) {
+        this.#state = mergeObjects(this.#state, state);
+        this.#stateUpdate.emit({ type, state: this.#state });
+    }
+}
+window.blueprintuiGlobal ?? (window.blueprintuiGlobal = new GlobalState());
+export const GlobalStateService = window.blueprintuiGlobal;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/services/i18n.service.d.ts

@@ -0,0 +1,40 @@
+export interface I18nStrings {
+    custom?: any;
+    actions: {
+        sort: string;
+        expand: string;
+        close: string;
+        resize: string;
+        filter: string;
+        loading: string;
+        show: string;
+        hide: string;
+        previous: string;
+        next: string;
+        first: string;
+        last: string;
+        today: string;
+        browse: string;
+        removeFile: string;
+        files: string;
+        resizeColumn: string;
+        closeDetails: string;
+        noData: string;
+        action: string;
+        dropTarget: string;
+        firstPage: string;
+        previousPage: string;
+        nextPage: string;
+        lastPage: string;
+        pageSize: string;
+    };
+}
+export declare const i18nRegistry: I18nStrings;
+declare type PartialRecursive<T> = T extends object ? {
+    [K in keyof T]?: PartialRecursive<T[K]>;
+} : T;
+export declare class I18nService {
+    static get keys(): Readonly<I18nStrings>;
+    static set keys(i18nRegistry: PartialRecursive<I18nStrings>);
+}
+export {};

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprintui/components/dist/lib/internals/services/i18n.service.js

@@ -0,0 +1,42 @@
+import { GlobalStateService } from './global.service.js';
+export const i18nRegistry = {
+    actions: {
+        sort: 'sort',
+        expand: 'expand',
+        close: 'close',
+        resize: 'resize',
+        filter: 'filter',
+        loading: 'loading',
+        show: 'show',
+        hide: 'hide',
+        previous: 'previous',
+        next: 'next',
+        first: 'first',
+        last: 'last',
+        today: 'today',
+        browse: 'browse',
+        removeFile: 'remove file',
+        files: 'files',
+        resizeColumn: 'resize column',
+        closeDetails: 'close details',
+        noData: 'no results found',
+        action: 'action',
+        dropTarget: 'drop item',
+        firstPage: 'go to first page',
+        previousPage: 'go to previous page',
+        nextPage: 'go to next page',
+        lastPage: 'go to last page',
+        pageSize: 'items per page'
+    }
+};
+export class I18nService {
+    static get keys() {
+        if (Object.keys(GlobalStateService.state.i18nRegistry).length === 0) {
+            GlobalStateService.dispatch('i18nRegistry', { i18nRegistry });
+        }
+        return { ...i18nRegistry, ...GlobalStateService.state.i18nRegistry };
+    }
+    static set keys(i18nRegistry) {
+        GlobalStateService.dispatch('i18nRegistry', { i18nRegistry });
+    }
+}