@react-md/core 1.0.0-next.1 → 1.0.0-next.10

package/src/form/SelectValue.tsx

@@ -1,39 +0,0 @@
-import { cnb } from "cnbuilder";
-import { type ReactElement } from "react";
-import { bem } from "../utils/bem.js";
-import { type OptionProps } from "./Option.js";
-
-const styles = bem("rmd-select-value");
-
-/**
- * @remarks \@since 6.0.0
- */
-export interface SelectValueProps extends Partial<OptionProps> {
-  disableAddon: boolean;
-}
-
-/**
- * **Server Component**
- *
- * This component is used to render the current option.
- *
- * @remarks \@since 6.0.0
- * @internal
- */
-export function SelectValue(props: SelectValueProps): ReactElement {
-  const { leftAddon, disableAddon, children: propChildren } = props;
-
-  let children = propChildren;
-  // when the children are a string or number, wrap it in additional span so
-  // that overflow can be ellipsis-ed
-  if (typeof children === "string" || typeof children === "number") {
-    children = <span className={styles("v")}>{children}</span>;
-  }
-
-  return (
-    <div className={cnb(styles())}>
-      {!disableAddon && leftAddon}
-      {children}
-    </div>
-  );
-}

package/src/utils/__tests__/filters.ts

@@ -1,279 +0,0 @@
-import { describe, expect, it, jest } from "@jest/globals";
-import { caseInsensitiveFilter, fuzzyFilter } from "../filters.js";
-
-const FRUITS = ["Apple", "Banana", "Mango", "Orange"];
-
-describe("caseInsensitiveFilter", () => {
-  it("should return the list if it is empty or there is no query string", () => {
-    const list1: string[] = [];
-    const list2 = ["item1", "item2"];
-
-    expect(caseInsensitiveFilter({ query: "", list: list1 })).toBe(list1);
-    expect(caseInsensitiveFilter({ query: "", list: list2 })).toBe(list2);
-
-    expect(caseInsensitiveFilter({ query: "string", list: list1 })).toBe(list1);
-  });
-
-  it("should filter out all items that do not contain the query string ignoring case", () => {
-    const expected1 = ["Apple"];
-    expect(caseInsensitiveFilter({ query: "ap", list: FRUITS })).toEqual(
-      expected1
-    );
-    expect(caseInsensitiveFilter({ query: "aP", list: FRUITS })).toEqual(
-      expected1
-    );
-    expect(caseInsensitiveFilter({ query: "AP", list: FRUITS })).toEqual(
-      expected1
-    );
-
-    const expected2 = ["Banana", "Mango", "Orange"];
-    expect(caseInsensitiveFilter({ query: "an", list: FRUITS })).toEqual(
-      expected2
-    );
-    expect(caseInsensitiveFilter({ query: "AN", list: FRUITS })).toEqual(
-      expected2
-    );
-    expect(caseInsensitiveFilter({ query: "aN", list: FRUITS })).toEqual(
-      expected2
-    );
-  });
-
-  it("should allow for filtering by matches that start with the query string instead of contain only", () => {
-    expect(
-      caseInsensitiveFilter({
-        query: "ap",
-        list: FRUITS,
-        startsWith: true,
-      })
-    ).toEqual(["Apple"]);
-    expect(
-      caseInsensitiveFilter({
-        query: "an",
-        list: FRUITS,
-        startsWith: true,
-      })
-    ).toEqual([]);
-
-    const list = ["Item 1", "This is Item 1"];
-    expect(
-      caseInsensitiveFilter({
-        query: "item",
-        list,
-        startsWith: true,
-      })
-    ).toEqual(["Item 1"]);
-  });
-
-  it("should work on objects", () => {
-    const apple = { name: "Apple", value: 0 };
-    const banana = { name: "Banana", value: 1 };
-    const mango = { name: "Mango", value: 2 };
-    const orange = { name: "Orange", value: 3 };
-    const list = [apple, banana, mango, orange];
-
-    expect(
-      caseInsensitiveFilter({
-        query: "ap",
-        list,
-        extractor: (item) => item.name,
-      })
-    ).toEqual([apple]);
-    expect(
-      caseInsensitiveFilter({
-        query: "2",
-        list,
-        extractor: (item) => `${item.value}`,
-      })
-    ).toEqual([mango]);
-
-    expect(
-      caseInsensitiveFilter({
-        query: "an",
-        list,
-        extractor: (item) => item.name,
-      })
-    ).toEqual([banana, mango, orange]);
-  });
-
-  it("should allow whitespace to be trimmed", () => {
-    expect(
-      caseInsensitiveFilter({
-        list: FRUITS,
-        query: "   app",
-        whitespace: "trim",
-      })
-    ).toEqual(["Apple"]);
-    expect(
-      caseInsensitiveFilter({
-        list: FRUITS,
-        query: "   app   ",
-        whitespace: "trim",
-      })
-    ).toEqual(["Apple"]);
-  });
-
-  it("should throw an error if an extractor is not provided for a non-string list", () => {
-    expect(() =>
-      // @ts-expect-error
-      caseInsensitiveFilter({ query: "q", list: [0, 1, 2] })
-    ).toThrow(
-      "A `TextExtractor` must be provided to `caseInsensitiveFilter` for lists that do not contain strings"
-    );
-
-    expect(() =>
-      // @ts-expect-error
-      caseInsensitiveFilter({ query: "q", list: [null, undefined] })
-    ).toThrow(
-      "A `TextExtractor` must be provided to `caseInsensitiveFilter` for lists that do not contain strings"
-    );
-
-    expect(() =>
-      // @ts-expect-error
-      caseInsensitiveFilter({ query: "q", list: [{ name: "Qwerty" }] })
-    ).toThrow(
-      "A `TextExtractor` must be provided to `caseInsensitiveFilter` for lists that do not contain strings"
-    );
-  });
-});
-
-describe("fuzzyFilter", () => {
-  it("should return the list as-is if it is empty or there is no query string", () => {
-    const list1: string[] = [];
-    const list2 = ["item1", "item2"];
-
-    expect(
-      fuzzyFilter({
-        list: list1,
-        query: "",
-      })
-    ).toBe(list1);
-    expect(
-      fuzzyFilter({
-        list: list1,
-        query: "query",
-      })
-    ).toBe(list1);
-
-    expect(
-      fuzzyFilter({
-        list: list2,
-        query: "",
-      })
-    ).toBe(list2);
-  });
-
-  it("should filter the list by ensuring that the letters just appear in order in the string", () => {
-    expect(
-      fuzzyFilter({
-        list: FRUITS,
-        query: "ae",
-      })
-    ).toEqual(["Apple", "Orange"]);
-    expect(
-      fuzzyFilter({
-        list: FRUITS,
-        query: "aE",
-      })
-    ).toEqual(["Apple", "Orange"]);
-
-    const nonDeprecatedStringPropertyNames = [
-      "at",
-      "charAt",
-      "charCodeAt",
-      "codePointAt",
-      "concat",
-      "constructor",
-      "endsWith",
-      "includes",
-      "indexOf",
-      "lastIndexOf",
-      "length",
-      "localeCompare",
-      "match",
-      "matchAll",
-      "normalize",
-      "padEnd",
-      "padStart",
-      "repeat",
-      "replace",
-      "replaceAll",
-      "search",
-      "slice",
-      "split",
-      "startsWith",
-      "substring",
-      "toLocaleLowerCase",
-      "toLocaleUpperCase",
-      "toLowerCase",
-      "toString",
-      "toUpperCase",
-      "trim",
-      "trimEnd",
-      "trimStart",
-      "valueOf",
-    ];
-
-    expect(
-      fuzzyFilter({
-        list: nonDeprecatedStringPropertyNames,
-        query: "la",
-      })
-    ).toEqual([
-      "lastIndexOf",
-      "localeCompare",
-      "replace",
-      "replaceAll",
-      "toLocaleLowerCase",
-      "toLocaleUpperCase",
-      "toLowerCase",
-    ]);
-  });
-
-  it("should lazy-create the regexp", () => {
-    const reg = jest.spyOn(global, "RegExp");
-
-    const list = Array.from({ length: 100000 }, (_, i) => `${i} Item`);
-    fuzzyFilter({ list, query: "1" });
-    expect(reg).toHaveBeenCalledTimes(1);
-  });
-
-  it("should support ignoring whitespace", () => {
-    const item1 = "Lorem ipsum";
-    const item2 = "another item";
-    const item3 = "in this string";
-    const item4 = "not interested, mate";
-    const item5 = "not in my house";
-    const list = [item1, item2, item3, item4, item5];
-
-    expect(
-      fuzzyFilter({
-        list,
-        query: "ti",
-        whitespace: "ignore",
-      })
-    ).toEqual([item2, item3, item4, item5]);
-
-    expect(
-      fuzzyFilter({
-        list,
-        query: "t i",
-        whitespace: "ignore",
-      })
-    ).toEqual([item2, item3, item4, item5]);
-
-    expect(
-      fuzzyFilter({
-        list,
-        query: "rem",
-        whitespace: "ignore",
-      })
-    ).toEqual([item1, item2]);
-    expect(
-      fuzzyFilter({
-        list,
-        query: "tem",
-        whitespace: "ignore",
-      })
-    ).toEqual([item2]);
-  });
-});

package/src/utils/filters.ts

@@ -1,320 +0,0 @@
-import type { TextExtractor } from "../types.js";
-
-/** @internal */
-const identity =
-  <T>(name: string) =>
-  (item: T): string => {
-    if (typeof item === "string") {
-      return item;
-    }
-
-    throw new Error(
-      `A \`TextExtractor\` must be provided to \`${name}\` for lists that do not contain strings`
-    );
-  };
-
-/**
- * @remarks \@since 6.0.0
- */
-export interface BaseFilterOptions<T> {
-  list: readonly T[];
-
-  /**
-   * The current query string. i.e. `"SeArch"`
-   */
-  query: string;
-
-  /**
-   * This is required if the list includes anything other than strings.
-   * @see {@link TextExtractor}
-   */
-  extractor?: TextExtractor<T>;
-
-  /**
-   * @defaultValue `"keep"`
-   */
-  whitespace?: "ignore" | "trim" | "keep";
-}
-
-/**
- * @internal
- * @remarks \@since 6.0.0
- */
-export interface FilterOptions<T> extends BaseFilterOptions<T> {
-  filter(query: string, value: string): boolean;
-  extractor: TextExtractor<T>;
-}
-
-/**
- * @internal
- * @remarks \@since 6.0.0
- */
-const toSearchString = (
-  s: string,
-  whitespace: "trim" | "ignore" | "keep"
-): string => {
-  let q = s.toLowerCase();
-  if (whitespace === "ignore") {
-    q = q.replace(/\s/g, "");
-  } else if (whitespace === "trim") {
-    q = q.trim();
-  }
-
-  return q;
-};
-
-/**
- * @internal
- * @remarks \@since 6.0.0
- */
-function filter<T>(options: FilterOptions<T>): readonly T[] {
-  const { list, query, filter, extractor, whitespace = "keep" } = options;
-  if (!list.length) {
-    return list;
-  }
-
-  const q = toSearchString(query, whitespace);
-  if (!q) {
-    return list;
-  }
-
-  return list.filter((item) =>
-    filter(q, toSearchString(extractor(item), whitespace))
-  );
-}
-
-/**
- * @remarks \@since 6.0.0
- */
-export interface CaseInsensitiveOptions<T> extends BaseFilterOptions<T> {
-  /**
-   * Set this to `true` if the item in the list must start with the query
-   * instead of only including it.
-   *
-   * @example
-   * ```ts
-   * const fruits = ["Apple", "Banana", "Grape", "Orange"];
-   *
-   * caseInsensitiveFilter({
-   *   list: fruits,
-   *   query: "ap",
-   * });
-   * // ["Apple", "Grape"]
-   *
-   * caseInsensitiveFilter({
-   *   list: fruits,
-   *   query: "ap",
-   *   startsWith: true,
-   * });
-   * // ["Apple"]
-   * ```
-   *
-   * @defaultValue `false`
-   */
-  startsWith?: boolean;
-}
-
-/**
- * @example
- * String list
- * ```ts
- * const fruits = ["Apple", "Banana", "Grape", "Orange"];
- *
- * caseInsensitiveFilter({
- *   list: fruits,
- *   query: "ap",
- * });
- * // ["Apple", "Grape"]
- *
- * caseInsensitiveFilter({
- *   list: fruits,
- *   query: "ap",
- *   startsWith: true,
- * });
- * // ["Apple"]
- *
- * caseInsensitiveFilter({
- *   list: fruits,
- *   query: "  a p",
- * });
- * // []
- *
- * caseInsensitiveFilter({
- *   list: fruits,
- *   query: "  a p",
- *   whitespace: "ignore",
- * });
- * // ["Apple", "Grape"]
- *
- * caseInsensitiveFilter({
- *   list: fruits,
- *   query: "  ap  ",
- *   whitespace: "trim",
- * });
- * // ["Apple", "Grape"]
- * ```
- *
- * @example
- * Objects
- * ```ts
- * const fruits = [
- *   { name: "Apple", value: 0 },
- *   { name: "Banana", value: 1 },
- *   { name: "Grape", value: 2 },
- *   { name: "Orange", value: 3 },
- * ];
- *
- * caseInsensitiveFilter({
- *   list: fruits,
- *   query: "ap",
- *   extractor: (item) => item.name,
- * });
- * // [{ name: "Apple", value: 0 }, { name: "Grape", value: 2 }]
- * ```
- *
- * @remarks \@since 6.0.0
- */
-export function caseInsensitiveFilter<T extends string>(
-  options: Omit<CaseInsensitiveOptions<T>, "extractor">
-): readonly T[];
-export function caseInsensitiveFilter<T>(
-  options: CaseInsensitiveOptions<T> & { extractor: TextExtractor<T> }
-): readonly T[];
-export function caseInsensitiveFilter<T>(
-  options: CaseInsensitiveOptions<T>
-): readonly T[] {
-  const {
-    list,
-    query,
-    extractor = identity("caseInsensitiveFilter"),
-    startsWith,
-    whitespace,
-  } = options;
-
-  return filter({
-    list,
-    query,
-    extractor,
-    whitespace,
-    filter(q, value) {
-      const matchIndex = value.indexOf(q);
-      if (startsWith) {
-        return matchIndex === 0;
-      }
-
-      return matchIndex !== -1;
-    },
-  });
-}
-
-/**
- * @remarks \@since 6.0.0
- */
-export type FuzzyFilterOptions<T> = BaseFilterOptions<T>;
-
-/**
- * Filters a list by making sure that all the letters appear in order ignoring
- * case, punctuation, whitespace, and special characters. This is kind of the
- * same filtering that appears in text editors.
- *
- * @example
- * Simple Example
- * ```ts
- * const list = [
- *   "at",
- *   "charAt",
- *   "charCodeAt",
- *   "codePointAt",
- *   "concat",
- *   "constructor",
- *   "endsWith",
- *   "includes",
- *   "indexOf",
- *   "lastIndexOf",
- *   "length",
- *   "localeCompare",
- *   "match",
- *   "matchAll",
- *   "normalize",
- *   "padEnd",
- *   "padStart",
- *   "repeat",
- *   "replace",
- *   "replaceAll",
- *   "search",
- *   "slice",
- *   "split",
- *   "startsWith",
- *   "substring",
- *   "toLocaleLowerCase",
- *   "toLocaleUpperCase",
- *   "toLowerCase",
- *   "toString",
- *   "toUpperCase",
- *   "trim",
- *   "trimEnd",
- *   "trimStart",
- *   "valueOf",
- * ];
- *
- * fuzzyFilter({ list: list, query: "la" });
- * // [
- * //   "lastIndexOf",
- * //    ^^
- * //   "localeCompare",
- * //    ^  ^
- * //   "replace",
- * //       ^^
- * //   "replaceAll",
- * //       ^^
- * //   "toLocaleLowerCase",
- * //      ^  ^
- * //   "toLocaleUpperCase",
- * //      ^  ^
- * //   "toLowerCase",
- * //      ^     ^
- * // ]
- * ```
- *
- * @remarks \@since 6.0.0
- */
-export function fuzzyFilter<T extends string>(
-  options: Omit<FuzzyFilterOptions<T>, "extractor">
-): readonly T[];
-export function fuzzyFilter<T>(
-  option: FuzzyFilterOptions<T> & { extractor: TextExtractor<T> }
-): readonly T[];
-export function fuzzyFilter<T>(options: FuzzyFilterOptions<T>): readonly T[] {
-  const {
-    list,
-    query,
-    extractor = identity("fuzzyFilter"),
-    whitespace,
-  } = options;
-
-  let regexp: RegExp;
-  return filter({
-    list,
-    query,
-    extractor,
-    whitespace,
-    filter(query, value) {
-      if (!regexp) {
-        regexp = new RegExp(
-          `${query}`
-            .split("")
-            .join("\\w*")
-            .replace(
-              /(\(|\||\)|\\(?!w\*)|\[|\|-|\.|\^|\+|\$|\?|^(?!w)\*)/g,
-              "\\$1"
-            )
-            // Couldn't get the matching of two '*' working, so replace them here..
-            .replace(/\*\*/g, "*\\*"),
-          "i"
-        );
-      }
-
-      return value.length > 0 && regexp.test(value);
-    },
-  });
-}