@cccsaurora/howler-ui 2.14.0-dev.257 → 2.14.0-dev.263

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

@@ -0,0 +1,21 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { VSBoxContext } from "../../layout/vsbox/VSBox.js";
+import { useContext } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import TuiTableHeader from "./TuiTableHeader.js";
+const TuiTableHead = ({ layout, columns }) => {
+  const {
+    state: { scrollTop }
+  } = useContext(VSBoxContext);
+  return /* @__PURE__ */ 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) => /* @__PURE__ */ jsx(TuiTableHeader, { width: layout.getWidth(column.column, true), column }, column.column))
+    }
+  );
+};
+export {
+  TuiTableHead as default
+};

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

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

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

@@ -0,0 +1,11 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { memo } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { useTranslation } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-i18next@14.1.3_i18next@23.16.8_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-i18next/dist/es/index.js";
+const TuiTableHeader = ({ width, column }) => {
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsx("div", { className: "tui-table-header", style: { minWidth: width }, children: /* @__PURE__ */ jsx("div", { children: column.i18nKey ? t(column.i18nKey) : column.label }) });
+};
+const TuiTableHeader$1 = memo(TuiTableHeader);
+export {
+  TuiTableHeader$1 as default
+};

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

@@ -0,0 +1,12 @@
+import { 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/components/elements/addons/lists/table/TuiTableLayout.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class TuiTableLayout {
+  constructor(tableWidth, bodyWidth, columns) {
+    __publicField(this, "tableWidth");
+    __publicField(this, "bodyWidth");
+    __publicField(this, "columns", []);
+    __publicField(this, "widths");
+    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 cw2 = this.columnWidth(c.width);
+      this.widths[c.column] = cw2;
+      _rw -= cw2;
+    });
+    const cw = _rw / _nw.length;
+    _nw.forEach((c) => {
+      this.widths[c.column] = cw;
+    });
+  }
+}
+export {
+  TuiTableLayout as default
+};

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

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { 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/components/elements/addons/lists/table/index.js

@@ -0,0 +1,4 @@
+const MATCHERS = ["like", "in", "is", ">=", "<=", "="];
+export {
+  MATCHERS
+};

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

@@ -0,0 +1,9 @@
+import { 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/components/elements/addons/search/SearchPagination.js

@@ -0,0 +1,17 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { Pagination } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/@mui+material@5.18.0_@emotion+react@11.14.0_@types+react@18.3.23_react@18.3.1__@emotion_19a5ee0476da228d66b5ad5c143bb0c3/node_modules/@mui/material/index.js";
+import { useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+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 ? /* @__PURE__ */ jsx(Pagination, { count, page, onChange: onPageChange, ...paginationProps }) : null;
+};
+export {
+  SearchPagination as default
+};

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

@@ -0,0 +1,8 @@
+import { 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/components/elements/addons/search/SearchTotal.js

@@ -0,0 +1,27 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { Typography } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/@mui+material@5.18.0_@emotion+react@11.14.0_@types+react@18.3.23_react@18.3.1__@emotion_19a5ee0476da228d66b5ad5c143bb0c3/node_modules/@mui/material/index.js";
+import { Trans } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-i18next@14.1.3_i18next@23.16.8_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-i18next/dist/es/index.js";
+const SearchTotal = ({ total, offset, pageLength, ...typographyProps }) => {
+  return /* @__PURE__ */ jsx(Typography, { ...typographyProps, children: total <= 1 ? /* @__PURE__ */ jsx(
+    Trans,
+    {
+      i18nKey: "search.result.showing.single",
+      values: {
+        total
+      }
+    }
+  ) : /* @__PURE__ */ jsx(
+    Trans,
+    {
+      i18nKey: "search.result.showing",
+      values: {
+        total,
+        offset: offset + 1,
+        length: pageLength + offset
+      }
+    }
+  ) });
+};
+export {
+  SearchTotal as default
+};

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

@@ -0,0 +1,19 @@
+import { TextFieldProps } from '@mui/material';
+import { parseEvent } from '@cccsaurora/howler-ui/commons/components/utils/keyboard';
+import { ReactElement } from 'react';
+import { PhraseSuggester } from '.';
+import { default as 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/components/elements/addons/search/phrase/Phrase.js

@@ -0,0 +1,137 @@
+import { jsx, jsxs } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { ClickAwayListener, TextField, InputAdornment, Popper, Paper, MenuList, MenuItem, ListItemText } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/@mui+material@5.18.0_@emotion+react@11.14.0_@types+react@18.3.23_react@18.3.1__@emotion_19a5ee0476da228d66b5ad5c143bb0c3/node_modules/@mui/material/index.js";
+import { parseEvent } from "../../../../../commons/components/utils/keyboard.js";
+import { useRef, useState, useEffect } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import WordLexer from "./word/WordLexer.js";
+import WordSuggestor from "./word/WordSuggester.js";
+const Phrase = ({
+  value = "",
+  variant = "outlined",
+  suggestions = [],
+  lexer,
+  suggester,
+  debug,
+  startAdornment,
+  endAdornment,
+  onChange,
+  onKeyDown,
+  ...props
+}) => {
+  var _a;
+  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");
+    inputEl.focus();
+    inputEl.setSelectionRange(suggest.token.startIndex, suggest.token.endIndex + 1);
+    document.execCommand("insertText", false, word);
+    setOptionsOpen(false);
+  };
+  const _suggest = (inputValue, offset = 0) => {
+    const _suggestions = suggesterRef.current.suggest(lex(inputValue, offset));
+    setOptions((_suggestions == null ? void 0 : _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();
+      menuRef.current.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 /* @__PURE__ */ jsx(ClickAwayListener, { onClickAway: () => setOptionsOpen(false), children: /* @__PURE__ */ jsxs("div", { ref: containerRef, style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsx(
+      TextField,
+      {
+        ref: inputRef,
+        ...props,
+        fullWidth: true,
+        autoComplete: "off",
+        value,
+        variant,
+        onChange: _onChange,
+        onKeyDown: _onInputKeyDown,
+        InputProps: {
+          ...props.InputProps,
+          onSelectCapture: _onSelectCapture,
+          startAdornment: startAdornment && /* @__PURE__ */ jsx(InputAdornment, { position: "start", children: startAdornment }),
+          endAdornment: endAdornment && /* @__PURE__ */ jsx(InputAdornment, { position: "end", children: endAdornment })
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Popper,
+      {
+        anchorEl: containerRef.current,
+        style: { width: "100%", zIndex: 100 },
+        open: optionsOpen && (options.length > 0 || debug && ((_a = analysisRef.current) == null ? void 0 : _a.tokens.length) > 0),
+        disablePortal: true,
+        children: /* @__PURE__ */ jsx(
+          Paper,
+          {
+            elevation: 2,
+            sx: { maxHeight: 200, overflow: "auto", borderTopRightRadius: 0, borderTopLeftRadius: 0 },
+            children: /* @__PURE__ */ jsx(
+              MenuList,
+              {
+                ref: menuRef,
+                onKeyDown: _onMenuKeyDown,
+                sx: {
+                  "&:focus": {
+                    outline: "none"
+                  }
+                },
+                children: options == null ? void 0 : options.map((o) => /* @__PURE__ */ jsx(MenuItem, { onClick: () => onWordClick(o), children: /* @__PURE__ */ jsx(ListItemText, { children: o }) }, o))
+              }
+            )
+          }
+        )
+      }
+    )
+  ] }) });
+};
+export {
+  Phrase as default
+};

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

@@ -0,0 +1,13 @@
+import { PhraseToken } from '.';
+import { default as 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/components/elements/addons/search/phrase/PhraseConsumer.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class PhraseConsumer {
+  constructor() {
+    __publicField(this, "_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());
+  }
+}
+export {
+  PhraseConsumer as default
+};

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

@@ -0,0 +1,26 @@
+import { PhraseAnalysis } from '.';
+import { default as 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>[];
+}

package/components/elements/addons/search/phrase/PhraseLexer.js

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class PhraseLexer {
+  constructor() {
+    __publicField(this, "_phrase", null);
+    __publicField(this, "_buffer", null);
+    __publicField(this, "_tokens", null);
+    __publicField(this, "_consumers", null);
+    __publicField(this, "_consumer", null);
+    __publicField(this, "_startIndex", 0);
+    __publicField(this, "_endIndex", -1);
+  }
+  find(cursor, tokens) {
+    const index = tokens.findIndex((t) => t.startIndex <= cursor && cursor <= t.endIndex);
+    const token = tokens.at(index);
+    return { index, token };
+  }
+  parse(phrase, cursor = 0) {
+    this._phrase = phrase;
+    this._buffer = [];
+    this._tokens = [];
+    this._consumers = this.consumers();
+    this._consumer = null;
+    this._startIndex = 0;
+    this._endIndex = -1;
+    for (let i = 0; i < this._phrase.length; i++) {
+      this._endIndex += 1;
+      const next = this._phrase[i];
+      this._buffer.push(next);
+      let newLock = false;
+      if (!this._consumer) {
+        this._consumer = this.lock();
+        if (this._consumer) {
+          newLock = true;
+          this._consumer.init(this._buffer, this);
+        }
+      }
+      if (this._consumer) {
+        if (newLock) {
+          newLock = false;
+        } else {
+          this._consumer.append(next, this);
+        }
+        const token = this._consumer.consume(this);
+        if (token) {
+          this._tokens.push(token);
+          this._buffer = [];
+          this._consumer = null;
+          this._startIndex = this._endIndex + 1;
+        }
+      }
+    }
+    this._tokens.push({ type: "eop", startIndex: phrase.length, endIndex: phrase.length, value: "" });
+    const flatTokens = this._tokens.flatMap((t) => t.children && t.children.length > 0 ? t.children : [t]);
+    const { token: parent, index: parentIndex } = this.find(cursor, this._tokens);
+    const { token: current, index: currentIndex } = this.find(cursor, flatTokens);
+    const filter = cursor === current.startIndex && flatTokens[currentIndex - 1] ? flatTokens[currentIndex - 1] : current;
+    return {
+      cursor,
+      parentIndex,
+      parent,
+      currentIndex,
+      current,
+      suggest: {
+        token: filter,
+        parent: this.find(filter.startIndex, this._tokens).token,
+        value: filter.value.substring(0, cursor - filter.startIndex)
+      },
+      tokens: this._tokens
+    };
+  }
+  lock() {
+    return this._consumers.find((c) => c.lock(this));
+  }
+  buffer() {
+    return this._buffer;
+  }
+  bufferValue() {
+    return this._buffer.join("");
+  }
+  start() {
+    return this._startIndex;
+  }
+  end() {
+    return this._endIndex;
+  }
+  ahead(inc) {
+    const start = this._endIndex + 1;
+    if (inc) {
+      return this._phrase.slice(start, start + inc);
+    }
+    return this._phrase.substring(start);
+  }
+  behind(inc) {
+    if (inc) {
+      return this.bufferValue().slice(-inc);
+    }
+    return this.bufferValue();
+  }
+  behindEndsWithAny(trim, ...values) {
+    const behind = trim ? this.behind().trimEnd() : this.behind();
+    return values.some((v) => behind.endsWith(v));
+  }
+  testBehind(regex) {
+    return regex.test(this.behind());
+  }
+  aheadStartsWithAny(trim, ...values) {
+    const ahead = trim ? this.ahead().trimStart() : this.ahead();
+    return values.some((v) => ahead.startsWith(v));
+  }
+  aheadIsEmpty(trim = false) {
+    return trim ? this.ahead().trim().length === 0 : this.ahead().length === 0;
+  }
+  testAhead(regex) {
+    return regex.test(this.ahead());
+  }
+}
+export {
+  PhraseLexer as default
+};

package/components/elements/addons/search/phrase/index.d.ts

@@ -0,0 +1,40 @@
+export type PhraseAnalysis = {
+    cursor: number;
+    parentIndex: number;
+    parent: PhraseToken;
+    currentIndex: number;
+    current: PhraseToken;
+    suggest: {
+        token: PhraseToken;
+        parent: PhraseToken;
+        value: string;
+    };
+    tokens?: PhraseToken[];
+};
+export type PhraseToken = {
+    value: string;
+    startIndex: number;
+    endIndex: number;
+    type?: string;
+    children?: PhraseToken[];
+};
+export type PhraseSuggester = {
+    suggest: (phrase: PhraseAnalysis) => string[];
+};
+export type PhraseSuggestorValue = {
+    field: string;
+    values: string[];
+};
+export declare class PhraseBuffer {
+    constructor(type?: string);
+    private type;
+    private startIndex;
+    private endIndex;
+    private buffer;
+    init(startIndex: number, buffer?: string[]): PhraseBuffer;
+    append(value: string): PhraseBuffer;
+    value(): string;
+    start(index?: number): number;
+    end(index?: number): number;
+    token(): PhraseToken;
+}

package/components/elements/addons/search/phrase/index.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class PhraseBuffer {
+  constructor(type) {
+    __publicField(this, "type");
+    __publicField(this, "startIndex", 0);
+    __publicField(this, "endIndex", -1);
+    __publicField(this, "buffer", []);
+    this.type = type;
+  }
+  init(startIndex, buffer) {
+    this.buffer = buffer ? [...buffer] : [];
+    this.startIndex = startIndex;
+    this.endIndex = startIndex + (buffer ? buffer.length : 0);
+    return this;
+  }
+  append(value) {
+    this.buffer.push(value);
+    this.endIndex += value.length;
+    return this;
+  }
+  value() {
+    return this.buffer.join("");
+  }
+  start(index) {
+    if (index !== void 0) {
+      this.startIndex = index;
+    }
+    return this.startIndex;
+  }
+  end(index) {
+    if (index !== void 0) {
+      this.endIndex = index;
+    }
+    return this.endIndex;
+  }
+  token() {
+    return this.endIndex > 0 ? {
+      type: this.type,
+      value: this.value(),
+      startIndex: this.startIndex,
+      endIndex: this.endIndex - 1
+    } : null;
+  }
+}
+export {
+  PhraseBuffer
+};

package/components/elements/addons/search/phrase/word/WordLexer.d.ts

@@ -0,0 +1,5 @@
+import { default as PhraseConsumer } from '../PhraseConsumer';
+import { default as PhraseLexer } from '../PhraseLexer';
+export default class WordLexer extends PhraseLexer {
+    consumers(): PhraseConsumer<PhraseLexer>[];
+}

package/components/elements/addons/search/phrase/word/WordLexer.js

@@ -0,0 +1,11 @@
+import PhraseLexer from "../PhraseLexer.js";
+import WhitespaceConsumer from "./consumers/WhitespaceConsumer.js";
+import WordConsumer from "./consumers/WordConsumer.js";
+class WordLexer extends PhraseLexer {
+  consumers() {
+    return [new WordConsumer(), new WhitespaceConsumer()];
+  }
+}
+export {
+  WordLexer as default
+};

package/components/elements/addons/search/phrase/word/WordSuggester.d.ts

@@ -0,0 +1,6 @@
+import { PhraseAnalysis, PhraseSuggester } from '..';
+export default class WordSuggestor implements PhraseSuggester {
+    private suggestions;
+    constructor(suggestions: string[]);
+    suggest(phrase: PhraseAnalysis): string[];
+}