alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/cli/util/PublicDefines.js

@@ -14,5 +14,6 @@ function publicDefines(environment) {
   );
 }
 export {
-  publicDefines
+  publicDefines,
+  publicEnvKeys
 };

package/dist/cli/util/RunForwarded.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runs a command given after `--` (`alinea dev -- next dev`) and takes its
+ * whole process tree down with us. Signals sent to us alone (`kill`, `pkill`,
+ * SIGHUP) would otherwise only reach the shell or version manager shims such
+ * as volta, which do not pass them on. The command stays in our process group
+ * so Ctrl+C and interactive terminal use work as before.
+ */
+export declare function runForwarded(command: string, env?: NodeJS.ProcessEnv, exit?: (code: number) => void): import("node:child_process").ChildProcess;
+/**
+ * Calls `onOrphan` once our parent process or forwarder is gone (killed with
+ * SIGKILL for example). A process started from a shell keeps it as parent.
+ */
+export declare function watchParent(onOrphan: () => void): () => void;

package/dist/cli/util/RunForwarded.js

@@ -0,0 +1,166 @@
+import {
+  onExit
+} from "../../chunks/chunk-RE6CDK2M.js";
+import {
+  __commonJS,
+  __toESM
+} from "../../chunks/chunk-CQ52GEHY.js";
+
+// node_modules/tree-kill/index.js
+import __import_child_process from "child_process";
+var require_tree_kill = __commonJS({
+  "node_modules/tree-kill/index.js"(exports, module) {
+    var childProcess = __import_child_process;
+    var spawn2 = childProcess.spawn;
+    var exec = childProcess.exec;
+    module.exports = function(pid, signal, callback) {
+      if (typeof signal === "function" && callback === void 0) {
+        callback = signal;
+        signal = void 0;
+      }
+      pid = parseInt(pid);
+      if (Number.isNaN(pid)) {
+        if (callback) {
+          return callback(new Error("pid must be a number"));
+        } else {
+          throw new Error("pid must be a number");
+        }
+      }
+      var tree = {};
+      var pidsToProcess = {};
+      tree[pid] = [];
+      pidsToProcess[pid] = 1;
+      switch (process.platform) {
+        case "win32":
+          exec("taskkill /pid " + pid + " /T /F", callback);
+          break;
+        case "darwin":
+          buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
+            return spawn2("pgrep", ["-P", parentPid]);
+          }, function() {
+            killAll(tree, signal, callback);
+          });
+          break;
+        // case 'sunos':
+        //     buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
+        //         killAll(tree, signal, callback);
+        //     });
+        //     break;
+        default:
+          buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
+            return spawn2("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+          }, function() {
+            killAll(tree, signal, callback);
+          });
+          break;
+      }
+    };
+    function killAll(tree, signal, callback) {
+      var killed = {};
+      try {
+        Object.keys(tree).forEach(function(pid) {
+          tree[pid].forEach(function(pidpid) {
+            if (!killed[pidpid]) {
+              killPid(pidpid, signal);
+              killed[pidpid] = 1;
+            }
+          });
+          if (!killed[pid]) {
+            killPid(pid, signal);
+            killed[pid] = 1;
+          }
+        });
+      } catch (err) {
+        if (callback) {
+          return callback(err);
+        } else {
+          throw err;
+        }
+      }
+      if (callback) {
+        return callback();
+      }
+    }
+    function killPid(pid, signal) {
+      try {
+        process.kill(parseInt(pid, 10), signal);
+      } catch (err) {
+        if (err.code !== "ESRCH") throw err;
+      }
+    }
+    function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+      var ps = spawnChildProcessesList(parentPid);
+      var allData = "";
+      ps.stdout.on("data", function(data) {
+        var data = data.toString("ascii");
+        allData += data;
+      });
+      var onClose = function(code) {
+        delete pidsToProcess[parentPid];
+        if (code != 0) {
+          if (Object.keys(pidsToProcess).length == 0) {
+            cb();
+          }
+          return;
+        }
+        allData.match(/\d+/g).forEach(function(pid) {
+          pid = parseInt(pid, 10);
+          tree[parentPid].push(pid);
+          tree[pid] = [];
+          pidsToProcess[pid] = 1;
+          buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+        });
+      };
+      ps.on("close", onClose);
+    }
+  }
+});
+
+// src/cli/util/RunForwarded.ts
+import { spawn } from "node:child_process";
+import { constants } from "node:os";
+var import_tree_kill = __toESM(require_tree_kill(), 1);
+var forwarded = ["SIGINT", "SIGTERM", "SIGHUP"];
+var forwarder = Number(process.env.ALINEA_FORWARDER_PID);
+delete process.env.ALINEA_FORWARDER_PID;
+function runForwarded(command, env = process.env, exit = (code) => process.exit(code)) {
+  const child = spawn(command, {
+    shell: true,
+    stdio: "inherit",
+    env: { ...env, ALINEA_FORWARDER_PID: String(process.pid) }
+  });
+  const kill = (signal = "SIGTERM") => {
+    if (child.pid) (0, import_tree_kill.default)(child.pid, signal);
+  };
+  const removeExitHandler = onExit(() => void child.kill());
+  const stopWatching = watchParent(() => kill());
+  for (const signal of forwarded) process.on(signal, kill);
+  child.on("exit", (code, signal) => {
+    removeExitHandler();
+    stopWatching();
+    for (const signal2 of forwarded) process.off(signal2, kill);
+    exit(code ?? 128 + (signal ? constants.signals[signal] : 0));
+  });
+  return child;
+}
+function watchParent(onOrphan) {
+  const parent = process.ppid;
+  const timer = setInterval(() => {
+    if (process.ppid === parent && (!forwarder || isAlive(forwarder))) return;
+    clearInterval(timer);
+    onOrphan();
+  }, 1e3);
+  timer.unref();
+  return () => clearInterval(timer);
+}
+function isAlive(pid) {
+  try {
+    return process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+}
+export {
+  runForwarded,
+  watchParent
+};

package/dist/cli/util/WarnPublicEnv.js

@@ -1,6 +1,7 @@
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/cli/util/WarnPublicEnv.ts
+import { publicEnvKeys } from "./PublicDefines.js";
 var ignore = /* @__PURE__ */ new Set(["FORCE_COLOR", "NODE_ENV"]);
 var mockProcess = {
   env: new Proxy(
@@ -8,6 +9,7 @@ var mockProcess = {
     {
       get(target, key) {
         if (ignore.has(key)) return;
+        if (publicEnvKeys.some((prefix) => key.startsWith(prefix))) return;
         console.warn(
           `process.env.${key} is not defined on the client. If this variable is required in the browser, prefix the variable with PUBLIC_ and restart Alinea.`
         );

package/dist/cloud/CloudHandshake.js

@@ -1,6 +1,8 @@
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/cloud/CloudHandshake.ts
+import { jwks } from "alinea/backend/util/JWKS";
+import { HttpError } from "alinea/core/HttpError";
 import { decode, verify } from "alinea/core/util/JWT";
 import { isRecord } from "alinea/core/util/Objects";
 import { cloudConfig } from "./CloudConfig.js";
@@ -10,11 +12,6 @@ var CloudHandshakeError = class extends Error {
 var CloudHandshakeServiceError = class extends Error {
   name = "CloudHandshakeServiceError";
 };
-var keysPromise;
-var keysExpireAt = 0;
-var lastForcedRefreshAt = 0;
-var keyCacheLifetime = 5 * 60 * 1e3;
-var forcedRefreshInterval = 60 * 1e3;
 var verificationMessages = {
   "Invalid signature": "Handshake token signature is invalid",
   "Token expired": "Handshake token has expired",
@@ -26,10 +23,7 @@ async function verifyCloudHandshake(token, options) {
   const { header } = decodeHandshakeToken(token);
   if (!isRecord(header) || header.alg !== "RS256" || typeof header.kid !== "string" || !header.kid)
     throw new CloudHandshakeError("Handshake token header is invalid");
-  let key = (await cloudKeys()).find((key2) => key2.kid === header.kid);
-  if (!key) {
-    key = (await refreshCloudKeys()).find((key2) => key2.kid === header.kid);
-  }
+  const key = (await cloudKeys(header.kid)).find((key2) => key2.kid === header.kid);
   if (!key)
     throw new CloudHandshakeError("Handshake token signing key is unknown");
   const payload = await verify(token, key, { algorithms: ["RS256"] }).catch(
@@ -70,46 +64,15 @@ function verificationError(cause) {
     cause
   });
 }
-function cloudKeys() {
-  if (keysPromise && (keysExpireAt === 0 || Date.now() < keysExpireAt))
-    return keysPromise;
-  return loadCloudKeys();
-}
-function refreshCloudKeys() {
-  const now = Date.now();
-  if (keysPromise && keysExpireAt === 0) return keysPromise;
-  if (keysPromise && now - lastForcedRefreshAt < forcedRefreshInterval)
-    return keysPromise;
-  lastForcedRefreshAt = now;
-  return loadCloudKeys();
-}
-function loadCloudKeys() {
-  keysExpireAt = 0;
-  keysPromise = fetch(cloudConfig.jwks).then(async (response) => {
-    if (!response.ok)
-      throw new CloudHandshakeServiceError(
-        `Could not load handshake signing keys: ${response.status}`
-      );
-    const body = await response.json();
-    if (!isRecord(body) || !Array.isArray(body.keys))
-      throw new CloudHandshakeServiceError(
-        "Cloud returned invalid handshake signing keys"
-      );
-    keysExpireAt = Date.now() + keyCacheLifetime;
-    return body.keys.filter(isCloudKey);
-  }).catch((cause) => {
-    keysPromise = void 0;
-    keysExpireAt = 0;
-    if (cause instanceof CloudHandshakeServiceError) throw cause;
+async function cloudKeys(kid) {
+  try {
+    return await jwks(cloudConfig.jwks, kid);
+  } catch (cause) {
     throw new CloudHandshakeServiceError(
-      "Could not load handshake signing keys",
+      cause instanceof HttpError ? `Could not load handshake signing keys: ${cause.code}` : "Could not load handshake signing keys",
       { cause }
     );
-  });
-  return keysPromise;
-}
-function isCloudKey(value) {
-  return isRecord(value) && typeof value.kid === "string";
+  }
 }
 function normalizedCloudUrl() {
   return cloudConfig.url.replace(/\/$/, "");

package/dist/cloud/CloudRemote.js

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../chunks/chunk-DWR5A5KL.js";
+} from "../chunks/chunk-4VKHBA57.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/cloud/CloudRemote.ts
@@ -55,7 +55,7 @@ var CloudRemote = class extends OAuth2 {
     const ctx = this.#context;
     if (!validApiKey(ctx.apiKey)) return;
     return parseOutcome(
-      fetch(
+      read(
         cloudConfig.tree,
         json({
           method: "POST",
@@ -72,7 +72,7 @@ var CloudRemote = class extends OAuth2 {
   }
   async *getBlobs(shas, options = {}) {
     const ctx = this.#context;
-    const response = await fetch(cloudConfig.blobs, {
+    const response = await read(cloudConfig.blobs, {
       method: "POST",
       body: JSON.stringify({ shas }),
       signal: options.signal,
@@ -223,7 +223,7 @@ var CloudRemote = class extends OAuth2 {
     if (!validApiKey(ctx.apiKey)) return;
     const { entryId, locale } = parseDraftKey(draftKey);
     const data = await parseOutcome(
-      fetch(`${cloudConfig.drafts}/${draftKey}`, json({ headers: bearer(ctx) }))
+      read(`${cloudConfig.drafts}/${draftKey}`, json({ headers: bearer(ctx) }))
     );
     return data?.update ? {
       entryId,
@@ -252,7 +252,7 @@ var CloudRemote = class extends OAuth2 {
   revisions(file) {
     const ctx = this.#context;
     return parseOutcome(
-      fetch(
+      read(
         `${cloudConfig.history}?${new URLSearchParams({ file })}`,
         json({ headers: bearer(ctx) })
       )
@@ -261,7 +261,7 @@ var CloudRemote = class extends OAuth2 {
   revisionData(file, revisionId) {
     const ctx = this.#context;
     return parseOutcome(
-      fetch(
+      read(
         `${cloudConfig.history}?${new URLSearchParams({ file, ref: revisionId })}`,
         json({ headers: bearer(ctx) })
       )
@@ -273,7 +273,7 @@ var CloudRemote = class extends OAuth2 {
   listUsers() {
     const ctx = this.#context;
     return parseOutcome(
-      fetch(cloudConfig.users, json({ headers: bearer(ctx) }))
+      read(cloudConfig.users, json({ headers: bearer(ctx) }))
     );
   }
   createUser(user) {
@@ -315,6 +315,20 @@ var CloudRemote = class extends OAuth2 {
     );
   }
 };
+var readTimeout = 3e4;
+async function read(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    const message = `No response from ${url} within ${readTimeout / 1e3}s`;
+    controller.abort(new HttpError(504, message));
+  }, readTimeout);
+  const signal = init.signal ? AbortSignal.any([init.signal, controller.signal]) : controller.signal;
+  try {
+    return await fetch(url, { ...init, signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function validApiKey(apiKey) {
   return Boolean(apiKey?.startsWith("alineapk"));
 }

package/dist/cms.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Build custom CMS UI: field views, section views and type or root views
+ * that the dashboard renders. Everything here needs the dashboard context.
+ *
+ * Generic UI building blocks (buttons, inputs, dialogs, ...) live in
+ * `alinea/components`.
+ *
+ * @module
+ */
+export { useField, useFieldError, useFieldKey, useFieldOptions, useFieldSetter, useFieldValue, useSiblingFieldValue } from './dashboard/cms/hooks.js';
+export { useEntry, useGraph, useLocale, useNavigate, usePolicy, usePreviewMetadata, useUser } from './dashboard/cms/hooks.js';
+export type { DashboardEntry, EntryActionProps } from './core/DashboardEntry.js';
+export type { DashboardLocation } from './dashboard/Href.js';
+export type { Policy } from './core/Role.js';
+export type { PreviewMetadata } from './core/Preview.js';
+export type { User } from './core/User.js';
+export { EditField, type EditFieldProps, EditFields, type EditFieldsProps } from './dashboard/app/EntryFields.js';
+export { FieldChrome, type FieldChromeProps } from './dashboard/cms/FieldChrome.js';
+export { EntryTable, type EntryTableProps } from './dashboard/cms/EntryTable.js';
+export type { OverviewActionProps, OverviewCellProps, OverviewEntry, OverviewHeaderProps } from './core/Overview.js';
+export type { FieldViewProps, RootViewProps, SectionViewProps, TypeViewProps } from './dashboard/cms/ViewProps.js';

package/dist/cms.js

@@ -0,0 +1,49 @@
+import "./chunks/chunk-CQ52GEHY.js";
+
+// src/cms.ts
+import {
+  useField,
+  useFieldError,
+  useFieldKey,
+  useFieldOptions,
+  useFieldSetter,
+  useFieldValue,
+  useSiblingFieldValue
+} from "./dashboard/cms/hooks.js";
+import {
+  useEntry,
+  useGraph,
+  useLocale,
+  useNavigate,
+  usePolicy,
+  usePreviewMetadata,
+  useUser
+} from "./dashboard/cms/hooks.js";
+import {
+  EditField,
+  EditFields
+} from "./dashboard/app/EntryFields.js";
+import {
+  FieldChrome
+} from "./dashboard/cms/FieldChrome.js";
+import { EntryTable } from "./dashboard/cms/EntryTable.js";
+export {
+  EditField,
+  EditFields,
+  EntryTable,
+  FieldChrome,
+  useEntry,
+  useField,
+  useFieldError,
+  useFieldKey,
+  useFieldOptions,
+  useFieldSetter,
+  useFieldValue,
+  useGraph,
+  useLocale,
+  useNavigate,
+  usePolicy,
+  usePreviewMetadata,
+  useSiblingFieldValue,
+  useUser
+};

package/dist/components/Alert.d.ts

@@ -0,0 +1,29 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { AriaProps, DataProps, IconType, StyleProps } from './types.js';
+export interface AlertProps extends StyleProps, AriaProps, DataProps {
+    variant?: 'default' | 'destructive' | 'warning';
+    icon?: IconType | ReactElement;
+    /**
+     * Defaults to `alert` for destructive alerts, which interrupts assistive
+     * technology, and `status` for the others
+     */
+    role?: 'alert' | 'status' | 'note';
+    children: ReactNode;
+}
+/** A callout for an important message: AlertTitle, AlertDescription and AlertActions */
+export declare function Alert({ variant, icon, role, className, children, ...props }: AlertProps): import("react").JSX.Element;
+export interface AlertTitleProps extends StyleProps, DataProps {
+    id?: string;
+    children: ReactNode;
+}
+export declare function AlertTitle({ className, ...props }: AlertTitleProps): import("react").JSX.Element;
+export interface AlertDescriptionProps extends StyleProps, DataProps {
+    id?: string;
+    children: ReactNode;
+}
+export declare function AlertDescription({ className, ...props }: AlertDescriptionProps): import("react").JSX.Element;
+export interface AlertActionsProps extends StyleProps, DataProps {
+    children: ReactNode;
+}
+/** Controls below the description */
+export declare function AlertActions({ className, ...props }: AlertActionsProps): import("react").JSX.Element;

package/dist/components/Alert.js

@@ -0,0 +1,86 @@
+import {
+  dist_default
+} from "../chunks/chunk-I4OYYAX5.js";
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/components/Alert.module.css
+var Alert_default = {
+  "AlertTitle": "alinea-AlertTitle",
+  "Alert": "alinea-Alert",
+  "AlertActions": "alinea-AlertActions",
+  "Alert-icon": "alinea-Alert-icon",
+  "AlertIcon": "alinea-Alert-icon",
+  "AlertDescription": "alinea-AlertDescription"
+};
+
+// src/components/Alert.tsx
+import { Icon } from "./Icon.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+var styles = dist_default(Alert_default);
+function Alert({
+  variant = "default",
+  icon,
+  role = variant === "destructive" ? "alert" : "status",
+  className,
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "alert",
+      role,
+      ...props,
+      "data-variant": variant,
+      "data-icon": icon ? true : void 0,
+      className: styles.Alert(dist_default.merge({ className })),
+      children: [
+        icon && /* @__PURE__ */ jsx(
+          Icon,
+          {
+            icon,
+            "data-slot": "alert-icon",
+            className: styles.Alert.icon()
+          }
+        ),
+        children
+      ]
+    }
+  );
+}
+function AlertTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "alert-title",
+      ...props,
+      className: styles.AlertTitle(dist_default.merge({ className }))
+    }
+  );
+}
+function AlertDescription({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "alert-description",
+      ...props,
+      className: styles.AlertDescription(dist_default.merge({ className }))
+    }
+  );
+}
+function AlertActions({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "alert-actions",
+      ...props,
+      className: styles.AlertActions(dist_default.merge({ className }))
+    }
+  );
+}
+export {
+  Alert,
+  AlertActions,
+  AlertDescription,
+  AlertTitle
+};

package/dist/components/AppShell.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import type { AriaProps, DataProps, StyleProps } from './types.js';
+export interface AppShellProps extends StyleProps, AriaProps, DataProps {
+    children: ReactNode;
+}
+/**
+ * The full height application layout: a NavRail next to the AppShellContent
+ * surface that holds the sidebars and pages.
+ */
+export declare function AppShell({ className, ...props }: AppShellProps): import("react").JSX.Element;
+export interface AppShellContentProps extends StyleProps, AriaProps, DataProps {
+    children: ReactNode;
+}
+/** The raised surface next to the NavRail, rendered as the main landmark */
+export declare function AppShellContent({ className, ...props }: AppShellContentProps): import("react").JSX.Element;

package/dist/components/AppShell.js

@@ -0,0 +1,38 @@
+import {
+  dist_default
+} from "../chunks/chunk-I4OYYAX5.js";
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/components/AppShell.module.css
+var AppShell_default = {
+  "AppShell": "alinea-AppShell",
+  "AppShellContent": "alinea-AppShellContent"
+};
+
+// src/components/AppShell.tsx
+import { jsx } from "react/jsx-runtime";
+var styles = dist_default(AppShell_default);
+function AppShell({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "app-shell",
+      ...props,
+      className: styles.AppShell(dist_default.merge({ className }))
+    }
+  );
+}
+function AppShellContent({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "main",
+    {
+      "data-slot": "app-shell-content",
+      ...props,
+      className: styles.AppShellContent(dist_default.merge({ className }))
+    }
+  );
+}
+export {
+  AppShell,
+  AppShellContent
+};

package/dist/components/AsyncList.d.ts

@@ -0,0 +1,52 @@
+import type { Key, Selection, SortDescriptor } from './types.js';
+export interface AsyncListLoadOptions<C> {
+    /** Aborted when a newer load replaces this one */
+    signal: AbortSignal;
+    /** The cursor returned by the previous page, set when loading more */
+    cursor?: C;
+    filterText: string;
+    sort?: SortDescriptor;
+}
+export interface AsyncListPage<T, C> {
+    items: Iterable<T>;
+    /** Where the next page starts, leave out when there are no more items */
+    cursor?: C | null;
+}
+export interface AsyncListOptions<T, C> {
+    load(options: AsyncListLoadOptions<C>): Promise<AsyncListPage<T, C>>;
+    initialSort?: SortDescriptor;
+    initialFilterText?: string;
+    initialSelectedKeys?: Iterable<Key>;
+    /** The key of an item, defaults to its `id` or `key` property */
+    getKey?: (item: T) => Key;
+}
+/**
+ * Items loaded page by page. Its fields plug into Table (`items`,
+ * `sortDescriptor`/`onSortChange`, `loading`, `onLoadMore`, `selectedKeys`/
+ * `onSelectionChange`) and ComboBox (`inputValue`/`onInputValueChange`,
+ * `loading`).
+ */
+export interface AsyncList<T> {
+    items: Array<T>;
+    /** True while loading the first page, the next page, sorting or filtering */
+    loading: boolean;
+    /** The error the last load failed with */
+    error?: Error;
+    /** Whether the last page returned a cursor */
+    hasMore: boolean;
+    loadMore(): void;
+    reload(): void;
+    /** Replaces an item, eg. after saving it, without loading the list again */
+    update(key: Key, item: T | ((previous: T) => T)): void;
+    remove(...keys: Array<Key>): void;
+    prepend(...items: Array<T>): void;
+    append(...items: Array<T>): void;
+    sortDescriptor?: SortDescriptor;
+    sort(descriptor: SortDescriptor): void;
+    filterText: string;
+    setFilterText(text: string): void;
+    selectedKeys: Selection;
+    setSelectedKeys(keys: Selection): void;
+}
+/** Loads a list of items, with sorting, filtering and paging */
+export declare function useAsyncList<T, C = string>({ load, initialSort, initialFilterText, initialSelectedKeys, getKey }: AsyncListOptions<T, C>): AsyncList<T>;