@cccsaurora/howler-ui 2.12.0-dev.30

package/dist/components/elements/addons/lists/hooks/useTuiListKeyboard.js

@@ -0,0 +1,41 @@
+import { isArrowDown, isArrowUp, isEnter } from 'commons/components/utils/keyboard';
+import { useCallback, useContext, useMemo } from 'react';
+import Throttler from 'utils/Throttler';
+import { TuiListItemsContext } from '../TuiListProvider';
+const THROTTLER = new Throttler(10);
+const useTuiListKeyboard = (onSelect) => {
+    const { items, movePrevious, moveNext } = useContext(TuiListItemsContext);
+    // Keyboard[keydown] event handler.
+    const onKeyDown = useCallback((event) => {
+        // console.log(`kd[${event.key}]`);
+        // event.preventDefault();
+        // going up.
+        if (isArrowUp(event.key)) {
+            event.preventDefault();
+            THROTTLER.debounce(() => movePrevious());
+        }
+        // going down.
+        else if (isArrowDown(event.key)) {
+            event.preventDefault();
+            THROTTLER.debounce(() => moveNext());
+        }
+        // select.
+        else if (isEnter(event.key)) {
+            const index = items.findIndex(i => !!i.cursor);
+            onSelect(items[index], index);
+        }
+    }, [items, movePrevious, moveNext, onSelect]);
+    // Register keyboard event handler.
+    const register = useCallback((element) => {
+        if (element) {
+            element.addEventListener('keydown', onKeyDown);
+        }
+        return () => {
+            element.removeEventListener('keydown', onKeyDown);
+        };
+    }, [onKeyDown]);
+    return useMemo(() => ({
+        register
+    }), [register]);
+};
+export default useTuiListKeyboard;

package/dist/components/elements/addons/lists/index.d.ts

@@ -0,0 +1,19 @@
+import type { ReactElement } from 'react';
+import TuiList from './TuiList';
+import TuiListElement from './TuiListElement';
+import TuiListProvider from './TuiListProvider';
+export type TuiListItemOnSelect<T> = (selection: TuiListItem<T>, rowIndex: number) => void;
+export type TuiListItem<T> = {
+    id: string | number;
+    details?: boolean;
+    cursor?: boolean;
+    selected?: boolean;
+    item: T;
+};
+export type TuiListItemProps<T> = {
+    item: TuiListItem<T>;
+    position: number;
+};
+export type TuiListMenuRenderer<T> = (props: TuiListItemProps<T>) => ReactElement | ReactElement[];
+export type TuiListItemRenderer<T> = (props: TuiListItemProps<T>, classRenderer: () => string) => ReactElement;
+export { TuiList, TuiListElement, TuiListProvider };

package/dist/components/elements/addons/lists/index.js

@@ -0,0 +1,4 @@
+import TuiList from './TuiList';
+import TuiListElement from './TuiListElement';
+import TuiListProvider from './TuiListProvider';
+export { TuiList, TuiListElement, TuiListProvider };

package/dist/components/elements/addons/lists/table/TuiTable.d.ts

@@ -0,0 +1,14 @@
+import type { TuiTableCellRenderer, TuiTableColumn, TuiTableRowDetailRenderer } from '.';
+import type { TuiListItemOnSelect, TuiListMenuRenderer } from '..';
+type TuiTableProps<T> = {
+    keyboard?: boolean;
+    flexPort?: boolean;
+    headless?: boolean;
+    columns: TuiTableColumn[];
+    onRowSelect?: TuiListItemOnSelect<T>;
+    menuRenderer?: TuiListMenuRenderer<T>;
+    detailRenderer?: TuiTableRowDetailRenderer<T>;
+    children?: TuiTableCellRenderer<T>;
+};
+declare const TuiTable: <T>({ keyboard, flexPort, headless, columns, onRowSelect, menuRenderer, detailRenderer, children }: TuiTableProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default TuiTable;

package/dist/components/elements/addons/lists/table/TuiTable.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { darken, emphasize, lighten, styled } from '@mui/material';
+import FlexPort from 'components/elements/addons/layout/FlexPort';
+import { useEffect, useRef, useState } from 'react';
+import { useResizeDetector } from 'react-resize-detector';
+import TuiTableBody from './TuiTableBody';
+import TuiTableHead from './TuiTableHead';
+import TuiTableLayout from './TuiTableLayout';
+const TableRoot = styled('div')(({ theme }) => ({
+    flex: 1,
+    display: 'flex',
+    flexDirection: 'column',
+    '.tui-table-row': {
+        wordBreak: 'break-all',
+        borderBottom: '1px solid',
+        borderBottomColor: theme.palette.mode === 'dark'
+            ? lighten(theme.palette.background.default, 0.05)
+            : darken(theme.palette.background.default, 0.05)
+    },
+    '.tui-table-cell': {
+        padding: theme.spacing(1)
+    },
+    '.tui-table-header': {
+        display: 'flex',
+        alignItems: 'center',
+        border: '1px dotted transparent',
+        padding: theme.spacing(1)
+    },
+    '.tui-table-header-active': {
+        border: '1px dotted',
+        borderColor: emphasize(theme.palette.background.default, 0.25),
+        backgroundColor: emphasize(theme.palette.background.default, 0.05)
+    },
+    '.tui-table-header-hover': {
+        '&:hover': {
+            cursor: 'pointer',
+            backgroundColor: emphasize(theme.palette.background.default, 0.05)
+        },
+        '&:hover .tui-table-header-menu-btn': {
+            opacity: 1
+        }
+    },
+    '.tui-table-header-menu': {},
+    '.tui-table-header-menu-btn': {
+        opacity: 0
+    },
+    '.tui-table-head': {
+        display: 'flex',
+        backgroundColor: theme.palette.background.default,
+        zIndex: theme.zIndex.appBar - 2
+    },
+    '.tui-table-divider': {
+        borderBottom: '1px solid',
+        borderBottomColor: theme.palette.divider
+    }
+}));
+const TuiTable = ({ keyboard, flexPort, headless, columns, onRowSelect, menuRenderer, detailRenderer, children }) => {
+    const { width, ref } = useResizeDetector({ handleHeight: false });
+    const { width: bodyWidth, ref: bodyRef } = useResizeDetector({ handleHeight: false });
+    const [layout, setLayout] = useState();
+    const widthRef = useRef(width);
+    useEffect(() => {
+        if (!flexPort || !layout) {
+            if (width && width !== widthRef.current) {
+                setLayout(new TuiTableLayout(width, width, columns));
+            }
+            widthRef.current = width;
+        }
+    }, [flexPort, layout, width, columns]);
+    useEffect(() => {
+        if (flexPort && layout) {
+            if (bodyWidth && bodyWidth !== widthRef.current) {
+                setLayout(new TuiTableLayout(width, bodyWidth, columns));
+            }
+            widthRef.current = bodyWidth;
+        }
+    }, [flexPort, layout, width, bodyWidth, columns]);
+    return (_jsxs(TableRoot, { ref: ref, "data-tuitable": "true", children: [!headless && layout && _jsx(TuiTableHead, { layout: layout, columns: columns }), layout &&
+                (flexPort ? (_jsx(FlexPort, { children: _jsx("div", { ref: bodyRef, children: _jsx(TuiTableBody, { keyboard: keyboard, layout: layout, columns: columns, onRowSelect: onRowSelect, menuRenderer: menuRenderer, detailRenderer: detailRenderer, children: children }) }) })) : (_jsx(TuiTableBody, { keyboard: keyboard, layout: layout, columns: columns, onRowSelect: onRowSelect, menuRenderer: menuRenderer, detailRenderer: detailRenderer, children: children })))] }));
+};
+export default TuiTable;

package/dist/components/elements/addons/lists/table/TuiTableBody.d.ts

@@ -0,0 +1,14 @@
+import type { TuiTableCellRenderer, TuiTableColumn, TuiTableRowDetailRenderer } from '.';
+import type { TuiListItemOnSelect, TuiListMenuRenderer } from '..';
+import type TuiTableLayout from './TuiTableLayout';
+type TuiTableBodyProps<T> = {
+    keyboard?: boolean;
+    layout: TuiTableLayout;
+    columns: TuiTableColumn[];
+    onRowSelect?: TuiListItemOnSelect<T>;
+    menuRenderer?: TuiListMenuRenderer<T>;
+    detailRenderer?: TuiTableRowDetailRenderer<T>;
+    children?: TuiTableCellRenderer<T>;
+};
+declare const TuiTableBody: <T>({ keyboard, layout, columns, onRowSelect, menuRenderer, detailRenderer, children }: TuiTableBodyProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default TuiTableBody;

package/dist/components/elements/addons/lists/table/TuiTableBody.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Collapse } from '@mui/material';
+import AppListEmpty from 'commons/components/display/AppListEmpty';
+import { get } from 'lodash-es';
+import { useCallback } from 'react';
+import { TuiListElement } from '..';
+import TuiListBase from '../TuiListBase';
+const TuiTableBody = ({ keyboard, layout, columns, onRowSelect, menuRenderer, detailRenderer, children }) => {
+    const trowRenderer = useCallback((props, classRenderer) => {
+        return (_jsxs("div", { className: `tui-table-row ${classRenderer()}`, children: [_jsxs("div", { style: { display: 'flex', position: 'relative' }, children: [columns.map((column, columnIndex) => {
+                            const value = get(props.item.item, column.path || column.column, '');
+                            return (_jsx("div", { className: "tui-table-cell", style: { minWidth: layout.getWidth(column.column) }, children: children ? children(value, columnIndex, column, props) : _jsx("div", { children: value }) }, column.column));
+                        }), menuRenderer && menuRenderer(props)] }), detailRenderer && (_jsx(Collapse, { in: props.item.details, unmountOnExit: true, children: detailRenderer(props) }))] }));
+    }, [layout, columns, menuRenderer, detailRenderer, children]);
+    return (_jsx(TuiListBase, { keyboard: keyboard, onSelect: onRowSelect, children: (items, onClick) => {
+            return items.length > 0 ? (items.map((item, index) => (_jsx(TuiListElement, { item: item, position: index, onSelect: onClick, children: trowRenderer }, item.id)))) : (_jsx(AppListEmpty, { mt: 4 }));
+        } }));
+};
+export default TuiTableBody;

package/dist/components/elements/addons/lists/table/TuiTableHead.d.ts

@@ -0,0 +1,8 @@
+import type { TuiTableColumn } from '.';
+import type TuiTableLayout from './TuiTableLayout';
+type TuiTableHeaderProps = {
+    layout: TuiTableLayout;
+    columns: TuiTableColumn[];
+};
+declare const TuiTableHead: ({ layout, columns }: TuiTableHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default TuiTableHead;

package/dist/components/elements/addons/lists/table/TuiTableHead.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { VSBoxContext } from 'components/elements/addons/layout/vsbox/VSBox';
+import { useContext } from 'react';
+import TuiTableHeader from './TuiTableHeader';
+const TuiTableHead = ({ layout, columns }) => {
+    const { state: { scrollTop } } = useContext(VSBoxContext);
+    return (_jsx("div", { "data-tuitable-header": "true", className: "tui-table-head tui-table-divider", style: { position: scrollTop ? 'sticky' : null, top: scrollTop || null }, children: columns.map(column => (_jsx(TuiTableHeader, { width: layout.getWidth(column.column, true), column: column }, column.column))) }));
+};
+export default TuiTableHead;

package/dist/components/elements/addons/lists/table/TuiTableHeader.d.ts

@@ -0,0 +1,6 @@
+import type { TuiTableColumn } from '.';
+declare const _default: import("react").MemoExoticComponent<({ width, column }: {
+    width: number;
+    column: TuiTableColumn;
+}) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/components/elements/addons/lists/table/TuiTableHeader.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+const TuiTableHeader = ({ width, column }) => {
+    const { t } = useTranslation();
+    return (_jsx("div", { className: "tui-table-header", style: { minWidth: width }, children: _jsx("div", { children: column.i18nKey ? t(column.i18nKey) : column.label }) }));
+};
+export default memo(TuiTableHeader);

package/dist/components/elements/addons/lists/table/TuiTableLayout.d.ts

@@ -0,0 +1,12 @@
+import type { TuiTableColumn } from '.';
+export default class TuiTableLayout {
+    private tableWidth;
+    private bodyWidth;
+    private columns;
+    private widths;
+    constructor(tableWidth: number, bodyWidth: number, columns: TuiTableColumn[]);
+    getWidth(column?: string, header?: boolean): number;
+    private isLast;
+    private columnWidth;
+    private compute;
+}

package/dist/components/elements/addons/lists/table/TuiTableLayout.js

@@ -0,0 +1,41 @@
+export default class TuiTableLayout {
+    tableWidth;
+    bodyWidth;
+    columns = [];
+    widths;
+    constructor(tableWidth, bodyWidth, columns) {
+        this.tableWidth = tableWidth;
+        this.bodyWidth = bodyWidth;
+        this.columns = columns;
+        this.compute();
+    }
+    getWidth(column, header) {
+        if (column) {
+            const extra = column && header && this.isLast(column) ? this.tableWidth - this.bodyWidth : 0;
+            return extra > 0 ? this.widths[column] + extra : this.widths[column];
+        }
+        return this.bodyWidth;
+    }
+    isLast(column) {
+        const index = this.columns.findIndex(c => c.column === column);
+        return index === this.columns.length - 1;
+    }
+    columnWidth(ratio) {
+        return (ratio / 12) * this.bodyWidth;
+    }
+    compute() {
+        let _rw = this.bodyWidth;
+        const _nw = this.columns.filter(c => !c.width);
+        const _ww = this.columns.filter(c => !!c.width);
+        this.widths = {};
+        _ww.forEach(c => {
+            const cw = this.columnWidth(c.width);
+            this.widths[c.column] = cw;
+            _rw -= cw;
+        });
+        const cw = _rw / _nw.length;
+        _nw.forEach(c => {
+            this.widths[c.column] = cw;
+        });
+    }
+}

package/dist/components/elements/addons/lists/table/index.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import type { TuiListItemProps } from '..';
+export declare const MATCHERS: readonly ["like", "in", "is", ">=", "<=", "="];
+export type TuiSearchMatcher = (typeof MATCHERS)[number];
+export type TuiTableColumn = {
+    column: string;
+    label?: string;
+    i18nKey?: string;
+    operators?: TuiSearchMatcher[];
+    path?: string;
+    sortable?: boolean;
+    width?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+};
+export type TuiTableRowDetailRenderer<T> = (props: TuiListItemProps<T>) => ReactNode;
+export type TuiTableCellRenderer<T> = (value: any, columnIndex: number, column: TuiTableColumn, props: TuiListItemProps<T>) => ReactNode;

package/dist/components/elements/addons/lists/table/index.js

@@ -0,0 +1 @@
+export const MATCHERS = ['like', 'in', 'is', '>=', '<=', '='];

package/dist/components/elements/addons/search/SearchPagination.d.ts

@@ -0,0 +1,9 @@
+import type { PaginationProps } from '@mui/material';
+type SearchPaginationProps = Omit<PaginationProps, 'onChange'> & {
+    limit: number;
+    offset: number;
+    total: number;
+    onChange: (nextOffset: number) => void;
+};
+declare const SearchPagination: ({ limit, offset, total, onChange, ...paginationProps }: SearchPaginationProps) => import("react/jsx-runtime").JSX.Element;
+export default SearchPagination;

package/dist/components/elements/addons/search/SearchPagination.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Pagination } from '@mui/material';
+import { useCallback } from 'react';
+const SearchPagination = ({ limit, offset, total, onChange, ...paginationProps }) => {
+    const onPageChange = useCallback((_event, nextPage) => {
+        onChange(nextPage === 1 ? 0 : (nextPage - 1) * limit);
+    }, [limit, onChange]);
+    const count = Math.ceil(total / limit);
+    const page = Math.floor((offset + 1) / limit) + 1;
+    return limit && total && limit < total ? (_jsx(Pagination, { count: count, page: page, onChange: onPageChange, ...paginationProps })) : null;
+};
+export default SearchPagination;

package/dist/components/elements/addons/search/SearchTotal.d.ts

@@ -0,0 +1,8 @@
+import type { TypographyProps } from '@mui/material';
+type SearchTotalProps = TypographyProps & {
+    total: number;
+    offset: number;
+    pageLength: number;
+};
+declare const SearchTotal: ({ total, offset, pageLength, ...typographyProps }: SearchTotalProps) => import("react/jsx-runtime").JSX.Element;
+export default SearchTotal;

package/dist/components/elements/addons/search/SearchTotal.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Typography } from '@mui/material';
+import { Trans } from 'react-i18next';
+const SearchTotal = ({ total, offset, pageLength, ...typographyProps }) => {
+    return (_jsx(Typography, { ...typographyProps, children: total <= 1 ? (_jsx(Trans, { i18nKey: "search.result.showing.single", values: {
+                total: total
+            } })) : (_jsx(Trans, { i18nKey: "search.result.showing", values: {
+                total: total,
+                offset: offset + 1,
+                length: pageLength + offset
+            } })) }));
+};
+export default SearchTotal;

package/dist/components/elements/addons/search/phrase/Phrase.d.ts

@@ -0,0 +1,19 @@
+import { type TextFieldProps } from '@mui/material';
+import { parseEvent } from 'commons/components/utils/keyboard';
+import { type ReactElement } from 'react';
+import type { PhraseSuggester } from '.';
+import type PhraseLexer from './PhraseLexer';
+export type PhraseProps = Omit<TextFieldProps, 'onChange' | 'onKeyDown' | 'variant'> & {
+    value: string;
+    variant?: 'filled' | 'outlined' | 'standard';
+    suggestions?: string[];
+    lexer?: PhraseLexer;
+    suggester?: PhraseSuggester;
+    debug?: boolean;
+    startAdornment?: ReactElement | ReactElement[];
+    endAdornment?: ReactElement | ReactElement[];
+    onChange: (phrase: string) => void;
+    onKeyDown?: (event: ReturnType<typeof parseEvent>) => void;
+};
+declare const Phrase: ({ value, variant, suggestions, lexer, suggester, debug, startAdornment, endAdornment, onChange, onKeyDown, ...props }: PhraseProps) => import("react/jsx-runtime").JSX.Element;
+export default Phrase;

package/dist/components/elements/addons/search/phrase/Phrase.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ClickAwayListener, InputAdornment, ListItemText, MenuItem, MenuList, Paper, Popper, TextField } from '@mui/material';
+import { parseEvent } from 'commons/components/utils/keyboard';
+import { useEffect, useRef, useState } from 'react';
+import WordLexer from './word/WordLexer';
+import WordSuggestor from './word/WordSuggester';
+const Phrase = ({ value = '', variant = 'outlined', suggestions = [], lexer, suggester, debug, startAdornment, endAdornment, onChange, onKeyDown, ...props }) => {
+    const containerRef = useRef();
+    const inputRef = useRef();
+    const menuRef = useRef();
+    const lexerRef = useRef(lexer || new WordLexer());
+    const analysisRef = useRef();
+    const suggesterRef = useRef(suggester || new WordSuggestor(suggestions));
+    const [optionsOpen, setOptionsOpen] = useState(false);
+    const [options, setOptions] = useState(suggestions);
+    useEffect(() => {
+        suggesterRef.current = suggester || new WordSuggestor(suggestions);
+    }, [suggester, suggestions]);
+    const lex = (inputValue, offset = 0) => {
+        let cursor = inputRef.current.querySelector('input').selectionStart + offset;
+        cursor = cursor < 0 ? 0 : cursor > inputValue.length ? inputValue.length : cursor;
+        analysisRef.current = lexerRef.current.parse(inputValue, cursor);
+        return analysisRef.current;
+    };
+    const onWordClick = (word) => {
+        const { suggest } = analysisRef.current;
+        const inputEl = inputRef.current.querySelector('input');
+        // NOTE: this is the only thing that works well with UNDO/REDO
+        // NOTE: the 'deprecated' insertText has no proper replacement to support this yet.
+        inputEl.focus();
+        inputEl.setSelectionRange(suggest.token.startIndex, suggest.token.endIndex + 1);
+        document.execCommand('insertText', false, word);
+        // NOTE: setRangeText does not work with UNDO/REDO [CTRL+Z|CTRL+SHIFT+Z]
+        // inputEl.setRangeText(word, current.startIndex, current.endIndex + 1, 'end');
+        setOptionsOpen(false);
+    };
+    const _suggest = (inputValue, offset = 0) => {
+        const _suggestions = suggesterRef.current.suggest(lex(inputValue, offset));
+        setOptions(_suggestions?.length > 0 ? _suggestions : [...suggestions]);
+    };
+    const _onChange = (event) => {
+        onChange(event.target.value);
+    };
+    const _onInputKeyDown = (event) => {
+        const parsedEvent = parseEvent(event);
+        const { isEnter, isCtrl, isSpace, isEscape, isArrowDown } = parsedEvent;
+        if (isArrowDown) {
+            event.preventDefault(); // prevent native scroll.
+            menuRef.current.focus(); // ensure suggestion menu gets focus.
+        }
+        else if (isCtrl && isSpace) {
+            setOptionsOpen(true);
+            _suggest(value);
+        }
+        else if (isEscape) {
+            setOptionsOpen(!optionsOpen);
+        }
+        if (isEnter && optionsOpen && options.length === 1) {
+            onWordClick(options[0]);
+            event.preventDefault();
+        }
+        else if (onKeyDown) {
+            onKeyDown(parsedEvent);
+        }
+    };
+    const _onSelectCapture = event => {
+        if (optionsOpen) {
+            _suggest(event.target.value);
+        }
+    };
+    const _onMenuKeyDown = (event) => {
+        const { isEscape } = parseEvent(event);
+        if (isEscape) {
+            inputRef.current.focus();
+            setOptionsOpen(false);
+        }
+    };
+    return (_jsx(ClickAwayListener, { onClickAway: () => setOptionsOpen(false), children: _jsxs("div", { ref: containerRef, style: { position: 'relative' }, children: [_jsx(TextField, { ref: inputRef, ...props, fullWidth: true, autoComplete: "off", value: value, variant: variant, onChange: _onChange, onKeyDown: _onInputKeyDown, InputProps: {
+                        ...props.InputProps,
+                        onSelectCapture: _onSelectCapture,
+                        startAdornment: startAdornment && _jsx(InputAdornment, { position: "start", children: startAdornment }),
+                        endAdornment: endAdornment && _jsx(InputAdornment, { position: "end", children: endAdornment })
+                    } }), _jsx(Popper, { anchorEl: containerRef.current, style: { width: '100%', zIndex: 100 }, open: optionsOpen && (options.length > 0 || (debug && analysisRef.current?.tokens.length > 0)), disablePortal: true, children: _jsx(Paper, { elevation: 2, sx: { maxHeight: 200, overflow: 'auto', borderTopRightRadius: 0, borderTopLeftRadius: 0 }, children: _jsx(MenuList, { ref: menuRef, onKeyDown: _onMenuKeyDown, sx: {
+                                '&:focus': {
+                                    outline: 'none'
+                                }
+                            }, children: options?.map(o => (_jsx(MenuItem, { onClick: () => onWordClick(o), children: _jsx(ListItemText, { children: o }) }, o))) }) }) })] }) }));
+};
+export default Phrase;

package/dist/components/elements/addons/search/phrase/PhraseConsumer.d.ts

@@ -0,0 +1,13 @@
+import type { PhraseToken } from '.';
+import type PhraseLexer from './PhraseLexer';
+export default abstract class PhraseConsumer<L extends PhraseLexer> {
+    protected _buffer: any[];
+    reset(): void;
+    init(buffer: string[], _lexer?: L): void;
+    append(next: string, _lexer?: L): void;
+    bufferValue(): string;
+    endsWithAny(...values: string[]): boolean;
+    test(regex: RegExp): boolean;
+    abstract lock(lexer: L): boolean;
+    abstract consume(lexer: L): PhraseToken;
+}

package/dist/components/elements/addons/search/phrase/PhraseConsumer.js

@@ -0,0 +1,22 @@
+export default class PhraseConsumer {
+    _buffer = [];
+    reset() {
+        this._buffer = [];
+    }
+    init(buffer, _lexer) {
+        this._buffer = [...buffer];
+    }
+    append(next, _lexer) {
+        this._buffer.push(next);
+    }
+    bufferValue() {
+        return this._buffer.join('');
+    }
+    endsWithAny(...values) {
+        const _bufferValue = this.bufferValue();
+        return values.some(v => _bufferValue.endsWith(v));
+    }
+    test(regex) {
+        return regex.test(this.bufferValue());
+    }
+}

package/dist/components/elements/addons/search/phrase/PhraseLexer.d.ts

@@ -0,0 +1,26 @@
+import type { PhraseAnalysis } from '.';
+import type PhraseConsumer from './PhraseConsumer';
+export default abstract class PhraseLexer {
+    private _phrase;
+    private _buffer;
+    private _tokens;
+    private _consumers;
+    private _consumer;
+    private _startIndex;
+    private _endIndex;
+    private find;
+    parse(phrase: string, cursor?: number): PhraseAnalysis;
+    lock(): PhraseConsumer<PhraseLexer>;
+    buffer(): string[];
+    bufferValue(): string;
+    start(): number;
+    end(): number;
+    ahead(inc?: number): string;
+    behind(inc?: number): string;
+    behindEndsWithAny(trim: boolean, ...values: string[]): boolean;
+    testBehind(regex: RegExp): boolean;
+    aheadStartsWithAny(trim: boolean, ...values: string[]): boolean;
+    aheadIsEmpty(trim?: boolean): boolean;
+    testAhead(regex: RegExp): boolean;
+    abstract consumers(): PhraseConsumer<PhraseLexer>[];
+}