Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
193 changes: 92 additions & 101 deletions src/routes/demos/demoDir/KeyValueQueryLanguage.tsx
Original file line number Diff line number Diff line change
@@ -1,115 +1,106 @@
import type { QueryLanguage } from "./QueryLanguage";

import classes from "./KeyValueQueryLanguage.module.css";

export const literalBackslashPlaceholder = "\u{E005C}";
export const filterKeys = [
"type",
"event",
"name",
"map",
"player",
"tag",
"has",
] as const;

export type FilterKey = (typeof filterKeys)[number];

export type Token =
export type Token = { raw: string } & (
| { type: "text"; value: string }
| { type: "filter"; value: { key: string; value: string } }
| { type: "invalid-filter"; value: { key: string; value: string } };

export type Parameters = {
filterPatterns: Record<string, string[]>;
};

export const backslashEscape = (value: string) =>
value
.replaceAll("\\", "\\\\")
.replaceAll(" ", "\\ ")
.replaceAll(literalBackslashPlaceholder, "\\");
| { type: "invalid-filter"; value: { key: string; value: string } }
);

export const keyValueQueryLanguage: QueryLanguage<Token, Parameters> = {
tokenizer: (query: string) => {
let escapeNextSymbol = false;
let currentToken = "";
const tokens: string[] = [];
export function tokenizeQuery(query: string): string[] {
const tokens: string[] = [];
let start = 0;
let quoted = false;
let escaped = false;

for (const symbol of query) {
switch (symbol) {
case " ":
if (escapeNextSymbol) {
currentToken += " ";
escapeNextSymbol = false;
} else {
tokens.push(currentToken);
currentToken = "";
}
break;
case "\\":
if (escapeNextSymbol) {
currentToken += "\\";
escapeNextSymbol = false;
} else {
escapeNextSymbol = true;
}
break;
default:
if (escapeNextSymbol) {
currentToken += literalBackslashPlaceholder;
escapeNextSymbol = false;
}
currentToken += symbol;
}
for (let index = 0; index < query.length; index++) {
const symbol = query[index];
if (escaped) {
escaped = false;
} else if (symbol === "\\") {
escaped = true;
} else if (symbol === '"') {
quoted = !quoted;
} else if (symbol === " " && !quoted) {
tokens.push(query.slice(start, index));
start = index + 1;
}
}

if (escapeNextSymbol) {
currentToken += literalBackslashPlaceholder;
}
tokens.push(currentToken);
tokens.push(query.slice(start));
return tokens;
}

return tokens;
},
parser: (token: string, { filterPatterns }): Token => {
const matches = /^(!?[a-zA-Z0-9-_]+):(.*)$/.exec(token);
if (matches !== null) {
const [_, key, value] = matches;
export function parseToken(token: string): Token {
const matches = /^(!?[a-zA-Z0-9-_]+):(.*)$/.exec(token);
if (matches !== null) {
const [_, key, rawValue] = matches;
const value = decodeQueryValue(rawValue);

if (Object.keys(filterPatterns).includes(key.replace(/^!/, ""))) {
return { type: "filter", value: { key, value } };
} else {
return { type: "invalid-filter", value: { key, value } };
}
if (filterKeys.some((filterKey) => filterKey === key.replace(/^!/, ""))) {
return { type: "filter", raw: token, value: { key, value } };
} else {
return { type: "invalid-filter", raw: token, value: { key, value } };
}
return { type: "text", value: token };
},
renderTokens: (tokens: Token[]) =>
tokens
.map((token, index) => {
switch (token.type) {
case "filter":
return (
<span
className={classes.filter}
key={`${index} ${token.value.key} ${token.value.value}`}
>
<span className={classes.filterKey}>
{backslashEscape(token.value.key)}
</span>
:
<span className={classes.filterValue}>
{backslashEscape(token.value.value)}
</span>
}
return { type: "text", raw: token, value: decodeQueryValue(token) };
}

export const renderTokens = (tokens: Token[]) =>
tokens
.map((token, index) => {
switch (token.type) {
case "filter":
return (
<span
className={classes.filter}
key={`${index} ${token.value.key} ${token.value.value}`}
>
<span className={classes.filterKey}>{token.value.key}</span>:
<span className={classes.filterValue}>
{token.raw.slice(token.value.key.length + 1)}
</span>
);
case "invalid-filter":
return (
<span
className={classes.invalidFilter}
key={`${index} ${token.value.key} ${token.value.value}`}
>
<span className={classes.filterKey}>
{backslashEscape(token.value.key)}
</span>
:
<span className={classes.filterValue}>
{backslashEscape(token.value.value)}
</span>
</span>
);
case "invalid-filter":
return (
<span
className={classes.invalidFilter}
key={`${index} ${token.value.key} ${token.value.value}`}
>
<span className={classes.filterKey}>{token.value.key}</span>:
<span className={classes.filterValue}>
{token.raw.slice(token.value.key.length + 1)}
</span>
);
default:
return backslashEscape(token.value);
}
})
.intersperse(" "),
};
</span>
);
default:
return token.raw;
}
})
.intersperse(" ");

export const highlight = (value: string) =>
renderTokens(tokenizeQuery(value).map(parseToken));

export const decodeQueryValue = (value: string) =>
value.replace(
/\\([\\ "])|"/g,
(_match, escaped: string | undefined) => escaped ?? ""
);

export const quoteQueryValue = (value: string) =>
/[\s"\\]/.test(value)
? `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`
: value;
7 changes: 0 additions & 7 deletions src/routes/demos/demoDir/QueryLanguage.tsx

This file was deleted.

59 changes: 37 additions & 22 deletions src/routes/demos/demoDir/SearchInput.tsx
Original file line number Diff line number Diff line change
@@ -1,29 +1,34 @@
import { useEffect, useState } from "react";

import { Combobox, Input, useCombobox } from "@mantine/core";
import {
Anchor,
Combobox,
Input,
ScrollArea,
useCombobox,
} from "@mantine/core";
import { useDebouncedValue } from "@mantine/hooks";
import { IconSearch } from "@tabler/icons-react";

import StyledInput, { type QueryLanguageProp } from "./StyledInput";
import { highlight } from "./KeyValueQueryLanguage";
import StyledInput from "./StyledInput";
import { useAutocomplete } from "./useAutocomplete";

import classes from "./SearchInput.module.css";

type SearchInputProps<Token, Parameters> = {
type SearchInputProps = {
query: string;
setQuery(newQuery: string): void;
debounceInterval: number;
filterPatterns: Record<string, string[]>;
} & QueryLanguageProp<Token, Parameters>;
};

export default function SearchInput<Token, Parameters>({
export default function SearchInput({
query,
setQuery,
debounceInterval,
filterPatterns,
queryLanguage,
queryLanguageParameters,
}: SearchInputProps<Token, Parameters>) {
}: SearchInputProps) {
const combobox = useCombobox();

const [rawQueryText, setRawQueryText] = useState(query);
Expand Down Expand Up @@ -72,26 +77,36 @@ export default function SearchInput<Token, Parameters>({
}}
placeholder="Search..."
component={StyledInput}
queryLanguage={queryLanguage}
queryLanguageParameters={queryLanguageParameters}
highlight={highlight}
inputRef={inputRef}
/>
</Combobox.Target>
<Combobox.Dropdown>
<Combobox.Options>
{dropdownItems.length === 0 ? (
<Combobox.Empty>Nothing found</Combobox.Empty>
) : (
dropdownItems.map((dropdownItem, index) => (
<Combobox.Option
key={index.toString() + dropdownItem}
value={dropdownItem}
>
{dropdownItem}
</Combobox.Option>
))
)}
<ScrollArea.Autosize mah={300} type="scroll">
{dropdownItems.length === 0 ? (
<Combobox.Empty>Nothing found</Combobox.Empty>
) : (
dropdownItems.map((dropdownItem, index) => (
<Combobox.Option
key={index.toString() + dropdownItem}
value={dropdownItem}
>
{dropdownItem}
</Combobox.Option>
))
)}
</ScrollArea.Autosize>
</Combobox.Options>
<Combobox.Footer>
Supports special search syntax{" "}
<Anchor
href="https://github.com/DemomanApp/DemoMan/wiki/Filtering"
target="_blank"
>
learn more
</Anchor>
</Combobox.Footer>
</Combobox.Dropdown>
</Combobox>
);
Expand Down
30 changes: 10 additions & 20 deletions src/routes/demos/demoDir/StyledInput/index.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -2,43 +2,33 @@ import { useCallback, useEffect, useRef } from "react";

import { useMergedRef } from "@mantine/hooks";

import type { QueryLanguage } from "../QueryLanguage";

import classes from "./StyledInput.module.css";

export type InputRefProp = {
inputRef?: React.RefObject<HTMLInputElement | null>;
};

export type QueryLanguageProp<Token, Parameters> = {
queryLanguage: QueryLanguage<Token, Parameters>;
queryLanguageParameters: Parameters;
};

type StyledInputProps<Token, Parameters> = React.ComponentProps<"input"> &
InputRefProp &
QueryLanguageProp<Token, Parameters>;
type StyledInputProps = React.ComponentProps<"input"> &
InputRefProp & {
value: string;
highlight(value: string): React.ReactNode;
};

export default <Token, Parameters>({
export default ({
value,
style,
className,
ref,
inputRef: inputRefProp,
queryLanguage,
queryLanguageParameters,
highlight,
...otherProps
}: StyledInputProps<Token, Parameters>) => {
}: StyledInputProps) => {
const inputRef = useRef<HTMLInputElement>(null);
const sizerRef = useRef<HTMLDivElement>(null);
const highlightRef = useRef<HTMLDivElement>(null);

const mergedInputRef = useMergedRef(inputRef, inputRefProp);

const tokens = queryLanguage
.tokenizer(value as string, queryLanguageParameters)
.map((token) => queryLanguage.parser(token, queryLanguageParameters));

const updateSizer = useCallback((input: string) => {
if (sizerRef.current !== null && inputRef.current !== null) {
sizerRef.current.innerText = input;
Expand All @@ -47,7 +37,7 @@ export default <Token, Parameters>({
}, []);

useEffect(() => {
updateSizer(value as string);
updateSizer(value);
}, [updateSizer, value]);

return (
Expand All @@ -60,7 +50,7 @@ export default <Token, Parameters>({
>
<div className={classes.wrapper}>
<div ref={highlightRef} className={classes.styledContent}>
{queryLanguage.renderTokens(tokens, queryLanguageParameters)}
{highlight(value)}
</div>
<div className={classes.inputWrapper}>
<div className={classes.sizer} ref={sizerRef} />
Expand Down
Loading
Loading