@league-of-foundry-developers/foundry-vtt-types 12.331.2-beta → 13.340.0

package/src/foundry/client-esm/applications/ui/notifications.d.mts

@@ -0,0 +1,208 @@
+/**
+ * A common framework for displaying notifications to the client.
+ * Submitted notifications are added to a queue, and up to {@link Notifications.MAX_ACTIVE} notifications are
+ * displayed at once. Each notification is displayed for {@link Notifications.LIFETIME_MS} milliseconds before being
+ * removed, at which point further notifications are pulled from the queue.
+ *
+ *
+ * @example Displaying Notification Messages
+ * ```js
+ * ui.notifications.error("This is a permanent error message", {permanent: true});
+ * ui.notifications.warn("LOCALIZED.WARNING.MESSAGE", {localize: true});
+ * ui.notifications.success("This is a success message, not logged to the console", {console: false});
+ * ui.notifications.info("LOCALIZED.FORMAT.STRING", {format: {key1: "foo", key2: "bar"}});
+ * ```
+ *
+ * @example Progress Bar Notification
+ * ```js
+ * const progress = ui.notifications.info("Thing Happening!", {progress: true});
+ * progress.update({pct: 0.25, message: "Still happening!"});
+ * progress.update({pct: 0.50, message: "Almost there!"});
+ * progress.update({pct: 0.75, message: "Stay on target!"});
+ * progress.update({pct: 1.0, message: "Done!"});
+ * ```
+ */
+declare class Notifications {
+  constructor();
+
+  /**
+   * The maximum number of active notifications.
+   * @defaultValue `5`
+   */
+  static MAX_ACTIVE: number;
+
+  /**
+   * The maximum number of active notifications.
+   * @defaultValue `5000`
+   */
+  static LIFETIME_MS: number;
+
+  /**
+   * Push a new notification into the queue
+   * @param message   - The content of the notification message
+   * @param type      - The type of notification, "info", "warning", and "error" are supported
+   *                    (default: `"info"`)
+   * @param options   - Additional options which affect the notification
+   *                    (default: `{}`)
+   * @returns The ID of the notification (positive integer)
+   * @remarks `type` and `options` use parameter defaults so `null` causes an error
+   */
+  notify<T extends Notifications.Type = "info">(
+    message: string,
+    type?: T,
+    options?: Notifications.NotifyOptions,
+  ): Readonly<Notifications.Notification<T>>;
+
+  /**
+   * Display a notification with the "info" type
+   * @param message - The content of the notification message
+   * @param options - Notification options passed to the notify function
+   * @returns The ID of the notification (positive integer)
+   * @remarks `options` use parameter defaults so `null` causes an error
+   */
+  info(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"info">>;
+
+  /**
+   * Display a notification with the "warning" type
+   * @param message - The content of the notification message
+   * @param options - Notification options passed to the notify function
+   * @returns The ID of the notification (positive integer)
+   * @remarks `options` use parameter defaults so `null` causes an error
+   */
+  warn(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"warning">>;
+
+  /**
+   * Display a notification with the "error" type
+   * @param message - The content of the notification message
+   * @param options - Notification options passed to the notify function
+   * @returns The ID of the notification (positive integer)
+   * @remarks `options` use parameter defaults so `null` causes an error
+   */
+  error(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"error">>;
+
+  /**
+   * Display a notification with the "success" type.
+   * @param message - The content of the success message
+   * @param options - Notification options passed to the notify function
+   * @returns The registered notification
+   */
+  success(message: string, options?: Notifications.NotifyOptions): Readonly<Notifications.Notification<"success">>;
+
+  /**
+   * Update the progress of the notification.
+   * @param notification - A Notification or ID to update
+   * @param update       - An incremental progress update
+   */
+  update(notification: Notifications.Notification | number, update: Notifications.UpdateOptions): void;
+
+  /**
+   * Remove the notification linked to the ID.
+   * @param id - The Notification or ID to remove
+   */
+  remove(id: Notifications.Notification | number): void;
+
+  /**
+   * Clear all notifications.
+   */
+  clear(): void;
+
+  #private: true;
+}
+
+declare abstract class AnyNotifications extends Notifications {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare namespace Notifications {
+  type Any = AnyNotifications;
+  type AnyConstructor = typeof AnyNotifications;
+
+  type Type = "info" | "warning" | "error" | "success";
+
+  interface Notification<T extends Type = Type> {
+    id: number;
+    type: T;
+    timestamp: number;
+    message: string;
+    permanent: boolean;
+    console: boolean;
+    active: boolean;
+    progress: boolean;
+    pct: number;
+    element?: HTMLLIElement;
+    remove?: () => void;
+    update?: (pct: number) => void;
+  }
+
+  interface FormatOptions {
+    /**
+     * Whether to escape the values of `format`
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    escape?: boolean | null | undefined;
+
+    /**
+     * Whether to clean the provided message string as untrusted user input.
+     * No cleaning is applied if `format` is passed and `escape` is true or `localize` is true and `format` is not passed.
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    clean?: boolean | null | undefined;
+
+    /**
+     * A mapping of formatting strings passed to Localization#format
+     */
+    format?: Record<string, string> | null | undefined;
+  }
+
+  interface NotifyOptions extends FormatOptions {
+    /**
+     * Should the notification be permanently displayed until dismissed
+     * @defaultValue `false`
+     * @remarks Overridden as `true` if `progress` is true. `null` equivalent to `false`
+     */
+    permanent?: boolean | null | undefined;
+
+    /**
+     * Does this Notification include a progress bar?
+     * @defaultValue `false`
+     * @remarks `null` equivalent to `false`
+     */
+    progress?: boolean | null | undefined;
+
+    /**
+     * Whether to localize the message content before displaying it
+     * @defaultValue `false`
+     */
+    localize?: boolean;
+
+    /**
+     * Whether to log the message to the console
+     * @defaultValue `true`
+     * @remarks `null` equivalent to `false`
+     */
+    console?: boolean | null | undefined;
+  }
+
+  interface UpdateOptions extends FormatOptions {
+    /**
+     * An update to the string message
+     */
+    message?: string | null | undefined;
+
+    /**
+     * Localize updates to presented progress text
+     * @defaultValue `false`
+     * @remarks `null` equivalent to `false`
+     */
+    localize?: boolean | null | undefined;
+
+    /**
+     * An update to the completion percentage
+     */
+    pct?: number | null | undefined;
+  }
+}
+
+export default Notifications;

package/src/foundry/client-esm/applications/ui/players.d.mts

@@ -0,0 +1,26 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * A UI element which displays the Users defined for this world.
+ * Currently active users are always displayed, while inactive users can be displayed on toggle.
+ * @remarks TODO: Stub
+ */
+declare class Players<
+  RenderContext extends Players.RenderContext = Players.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace Players {
+  interface UserContext {
+    id: string;
+  }
+
+  interface RenderContext {
+    active: UserContext[];
+    inactive: UserContext[];
+  }
+}
+
+export default Players;

package/src/foundry/client-esm/applications/ui/region-legend.d.mts

@@ -1,4 +1,4 @@
-import type { AnyObject, EmptyObject } from "../../../../types/utils.d.mts";
+import type { AnyObject, DeepPartial, EmptyObject } from "fvtt-types/utils";
 import type ApplicationV2 from "../api/application.d.mts";
 import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
 
@@ -8,5 +8,50 @@ import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts
 export default class RegionLegend<
   RenderContext extends AnyObject = EmptyObject,
   Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
-  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
-> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+  RenderOptions extends
+    HandlebarsApplicationMixin.ApplicationV2RenderOptions = HandlebarsApplicationMixin.ApplicationV2RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {
+  #RegionLegend: true;
+
+  static override DEFAULT_OPTIONS: DeepPartial<ApplicationV2.Configuration> & object;
+  static override PARTS: Record<string, HandlebarsApplicationMixin.HandlebarsTemplatePart>;
+
+  /** The currently viewed elevation range. */
+  elevation: { bottom: number; top: number };
+
+  protected override _configureRenderOptions(options: DeepPartial<RenderOptions>): void;
+
+  protected override _canRender(options: DeepPartial<RenderOptions>): false | void;
+
+  protected override _renderFrame(options: DeepPartial<RenderOptions>): Promise<HTMLElement>;
+
+  override close(options?: DeepPartial<ApplicationV2.ClosingOptions>): Promise<this>;
+
+  protected override _onFirstRender(
+    context: DeepPartial<RenderContext>,
+    options: DeepPartial<RenderOptions>,
+  ): Promise<void>;
+
+  protected override _onRender(context: DeepPartial<RenderContext>, options: DeepPartial<RenderOptions>): Promise<void>;
+
+  protected override _onClose(options: DeepPartial<RenderOptions>): void;
+
+  protected override _prepareContext(
+    options: DeepPartial<RenderOptions> & { isFirstRender: boolean },
+  ): Promise<RenderContext>;
+
+  /**
+   * Is this Region visible in this RegionLegend?
+   * @param region - The Region
+   * @internal
+   */
+  _isRegionVisible(region: RegionDocument.ConfiguredInstance): boolean;
+
+  /**
+   * Highlight a hovered region in the legend.
+   * @param region  - The Region
+   * @param hover   - Whether they are being hovered in or out
+   * @internal
+   */
+  _hoverRegion(region: RegionDocument.ConfiguredInstance, hover: boolean): void;
+}

package/src/foundry/client-esm/applications/ui/scene-controls.d.mts

@@ -0,0 +1,20 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * The Scene Controls UI element.
+ * @remarks TODO: Stub
+ */
+declare class SceneControls<
+  RenderContext extends SceneControls.RenderContext = SceneControls.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends SceneControls.RenderOptions = SceneControls.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace SceneControls {
+  interface RenderContext extends ApplicationV2.RenderContext {}
+
+  interface RenderOptions extends ApplicationV2.RenderOptions {}
+}
+
+export default SceneControls;

package/src/foundry/client-esm/applications/ui/scene-navigation.d.mts

@@ -0,0 +1,28 @@
+import type ApplicationV2 from "../api/application.d.mts";
+import type HandlebarsApplicationMixin from "../api/handlebars-application.d.mts";
+
+/**
+ * The Scene Navigation UI element.
+ * @remarks TODO: Stub
+ */
+declare class SceneNavigation<
+  RenderContext extends SceneNavigation.RenderContext = SceneNavigation.RenderContext,
+  Configuration extends ApplicationV2.Configuration = ApplicationV2.Configuration,
+  RenderOptions extends ApplicationV2.RenderOptions = ApplicationV2.RenderOptions,
+> extends HandlebarsApplicationMixin(ApplicationV2)<RenderContext, Configuration, RenderOptions> {}
+
+declare namespace SceneNavigation {
+  interface PreparedScene {
+    id: string;
+  }
+
+  interface RenderContext {
+    scenes: {
+      inactive: PreparedScene[];
+      active: PreparedScene[];
+    };
+    canExpand: number;
+  }
+}
+
+export default SceneNavigation;

package/src/foundry/client-esm/applications/ux/_module.d.mts

@@ -0,0 +1,14 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as ContextMenu } from "./context-menu.mjs";
+export { default as DragDrop } from "./drag-drop.mjs";
+export { default as Draggable } from "./draggable.mjs";
+export { default as FormDataExtended } from "./form-data-extended.mjs";
+export { default as HTMLSecret } from "./html-secret.mjs";
+export { default as ProseMirrorEditor } from "./prosemirror-editor.mjs";
+export { default as SearchFilter } from "./search-filter.mjs";
+export { default as Tabs } from "./tabs.mjs";
+export { default as TextEditor } from "./text-editor.mjs";